https://github.com/akkartik/mu/blob/master/apps/mu.subx
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238 == data
239
240 Program:
241 _Program-functions:
242 0/imm32
243 _Program-functions->payload:
244 0/imm32
245 _Program-types:
246 0/imm32
247 _Program-types->payload:
248 0/imm32
249 _Program-signatures:
250 0/imm32
251 _Program-signatures->payload:
252 0/imm32
253
254
255
256
257
258
259
260
261
262
263
264
265 Function-name:
266 0/imm32
267 Function-inouts:
268 8/imm32
269 Function-outputs:
270 0x10/imm32
271 Function-body:
272 0x18/imm32
273 Function-next:
274 0x20/imm32
275 Function-size:
276 0x28/imm32/40
277
278 Primitive-name:
279 0/imm32
280 Primitive-inouts:
281 8/imm32
282 Primitive-outputs:
283 0x10/imm32
284 Primitive-subx-name:
285 0x18/imm32
286 Primitive-subx-rm32:
287 0x20/imm32
288 Primitive-subx-r32:
289 0x24/imm32
290 Primitive-subx-imm32:
291 0x28/imm32
292 Primitive-subx-imm8:
293 0x2c/imm32
294 Primitive-subx-disp32:
295 0x30/imm32
296 Primitive-subx-xm32:
297 0x34/imm32
298 Primitive-subx-x32:
299 0x38/imm32
300 Primitive-next:
301 0x3c/imm32
302 Primitive-size:
303 0x44/imm32/68
304
305 Stmt-tag:
306 0/imm32
307
308 Block-stmts:
309 4/imm32
310 Block-var:
311 0xc/imm32
312
313 Stmt1-operation:
314 4/imm32
315 Stmt1-inouts:
316 0xc/imm32
317 Stmt1-outputs:
318 0x14/imm32
319
320 Vardef-var:
321 4/imm32
322
323 Regvardef-operation:
324 4/imm32
325 Regvardef-inouts:
326 0xc/imm32
327 Regvardef-outputs:
328 0x14/imm32
329
330 Stmt-size:
331 0x1c/imm32
332
333 Var-name:
334 0/imm32
335 Var-type:
336 8/imm32
337 Var-block-depth:
338 0x10/imm32
339 Var-offset:
340 0x14/imm32
341 Var-register:
342 0x18/imm32
343 Var-size:
344 0x20/imm32
345
346 List-value:
347 0/imm32
348 List-next:
349 8/imm32
350 List-size:
351 0x10/imm32
352
353
354 Stmt-var-value:
355 0/imm32
356 Stmt-var-next:
357 8/imm32
358 Stmt-var-is-deref:
359 0x10/imm32
360 Stmt-var-size:
361 0x14/imm32
362
363
364
365 Live-var-value:
366 0/imm32
367 Live-var-register-spilled:
368 8/imm32
369 Live-var-size:
370 0xc/imm32
371
372
373
374 Type-tree-is-atom:
375 0/imm32
376
377 Type-tree-value:
378 4/imm32
379 Type-tree-value-size:
380 8/imm32
381 Type-tree-parameter-name:
382 8/imm32
383
384 Type-tree-left:
385 4/imm32
386 Type-tree-right:
387 0xc/imm32
388
389 Type-tree-size:
390 0x14/imm32
391
392
393
394
395 Type-id:
396 0/imm32/write
397 0/imm32/read
398 0x100/imm32/size
399
400 0/imm32
401
402 "int"/imm32
403 "addr"/imm32
404 "array"/imm32
405 "handle"/imm32
406 "boolean"/imm32
407 0/imm32
408
409 "offset"/imm32
410
411 "byte"/imm32
412 0/imm32
413
414 0/imm32
415
416 "stream"/imm32
417 "slice"/imm32
418 "code-point"/imm32
419 "grapheme"/imm32
420
421
422 "float"/imm32
423
424 0/imm32
425
426
427
428 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32
429 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32
430 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32
431 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32
432 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32
433 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32 0/imm32
434
435 Primitive-type-ids:
436 0x44
437
438
439
440
441 Typeinfo-id:
442 0/imm32
443 Typeinfo-fields:
444 4/imm32
445
446
447
448
449
450 Typeinfo-total-size-in-bytes:
451 0xc/imm32
452 Typeinfo-next:
453 0x10/imm32
454 Typeinfo-size:
455 0x18/imm32
456
457
458
459 Typeinfo-fields-row-size:
460 0x10/imm32
461
462
463
464
465
466
467
468
469 Typeinfo-entry-input-var:
470 0/imm32
471 Typeinfo-entry-index:
472 8/imm32
473 Typeinfo-entry-output-var:
474 0xc/imm32
475 Typeinfo-entry-size:
476 0x14/imm32
477
478 == code
479
480 Entry:
481
482 89/<- %ebp 4/r32/esp
483 (new-segment *Heap-size Heap)
484
485 {
486
487 81 7/subop/compare *ebp 1/imm32
488 7e/jump-if-<= break/disp8
489
490 (kernel-string-equal? *(ebp+8) "test")
491 3d/compare-eax-and 0/imm32/false
492 74/jump-if-= break/disp8
493
494 (run-tests)
495
496 8b/-> *Num-test-failures 3/r32/ebx
497 eb/jump $mu-main:end/disp8
498 }
499
500 (convert-mu Stdin Stdout Stderr 0)
501 (flush Stdout)
502
503 bb/copy-to-ebx 0/imm32
504 $mu-main:end:
505 e8/call syscall_exit/disp32
506
507 convert-mu:
508
509 55/push-ebp
510 89/<- %ebp 4/r32/esp
511
512 50/push-eax
513
514 c7 0/subop/copy *Next-block-index 1/imm32
515 8b/-> *Primitive-type-ids 0/r32/eax
516 89/<- *Type-id 0/r32/eax
517 c7 0/subop/copy *_Program-functions 0/imm32
518 c7 0/subop/copy *_Program-functions->payload 0/imm32
519 c7 0/subop/copy *_Program-types 0/imm32
520 c7 0/subop/copy *_Program-types->payload 0/imm32
521 c7 0/subop/copy *_Program-signatures 0/imm32
522 c7 0/subop/copy *_Program-signatures->payload 0/imm32
523
524 (parse-mu *(ebp+8) *(ebp+0x10) *(ebp+0x14))
525 (populate-mu-type-sizes *(ebp+0x10) *(ebp+0x14))
526
527 (check-mu-types *(ebp+0x10) *(ebp+0x14))
528 (emit-subx *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
529 $convert-mu:end:
530
531 58/pop-to-eax
532
533 89/<- %esp 5/r32/ebp
534 5d/pop-to-ebp
535 c3/return
536
537 test-convert-empty-input:
538
539
540 55/push-ebp
541 89/<- %ebp 4/r32/esp
542
543 (clear-stream _test-input-stream)
544 (clear-stream $_test-input-buffered-file->buffer)
545 (clear-stream _test-output-stream)
546 (clear-stream $_test-output-buffered-file->buffer)
547
548 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
549 (flush _test-output-buffered-file)
550 (check-stream-equal _test-output-stream "" "F - test-convert-empty-input")
551
552 89/<- %esp 5/r32/ebp
553 5d/pop-to-ebp
554 c3/return
555
556 test-convert-function-skeleton:
557
558 55/push-ebp
559 89/<- %ebp 4/r32/esp
560
561 (clear-stream _test-input-stream)
562 (clear-stream $_test-input-buffered-file->buffer)
563 (clear-stream _test-output-stream)
564 (clear-stream $_test-output-buffered-file->buffer)
565
566 (write _test-input-stream "fn foo {\n")
567 (write _test-input-stream "}\n")
568
569 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
570 (flush _test-output-buffered-file)
571 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
577
578 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-skeleton/0")
579 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-skeleton/1")
580 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-skeleton/2")
581 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-skeleton/3")
582 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-skeleton/4")
583 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-skeleton/5")
584 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-skeleton/6")
585 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-skeleton/7")
586
587 89/<- %esp 5/r32/ebp
588 5d/pop-to-ebp
589 c3/return
590
591 test-convert-multiple-function-skeletons:
592
593 55/push-ebp
594 89/<- %ebp 4/r32/esp
595
596 (clear-stream _test-input-stream)
597 (clear-stream $_test-input-buffered-file->buffer)
598 (clear-stream _test-output-stream)
599 (clear-stream $_test-output-buffered-file->buffer)
600
601 (write _test-input-stream "fn foo {\n")
602 (write _test-input-stream "}\n")
603 (write _test-input-stream "fn bar {\n")
604 (write _test-input-stream "}\n")
605
606 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
607 (flush _test-output-buffered-file)
608 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
614
615 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-multiple-function-skeletons/0")
616 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-multiple-function-skeletons/1")
617 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-multiple-function-skeletons/2")
618 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-multiple-function-skeletons/3")
619 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-multiple-function-skeletons/4")
620 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-multiple-function-skeletons/5")
621 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-multiple-function-skeletons/6")
622 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-multiple-function-skeletons/7")
623
624 (check-next-stream-line-equal _test-output-stream "bar:" "F - test-convert-multiple-function-skeletons/10")
625 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-multiple-function-skeletons/11")
626 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-multiple-function-skeletons/12")
627 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-multiple-function-skeletons/13")
628 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-multiple-function-skeletons/14")
629 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-multiple-function-skeletons/15")
630 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-multiple-function-skeletons/16")
631 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-multiple-function-skeletons/17")
632
633 89/<- %esp 5/r32/ebp
634 5d/pop-to-ebp
635 c3/return
636
637 test-convert-function-with-arg:
638
639 55/push-ebp
640 89/<- %ebp 4/r32/esp
641
642 (clear-stream _test-input-stream)
643 (clear-stream $_test-input-buffered-file->buffer)
644 (clear-stream _test-output-stream)
645 (clear-stream $_test-output-buffered-file->buffer)
646
647 (write _test-input-stream "fn foo n: int {\n")
648 (write _test-input-stream "}\n")
649
650 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
651 (flush _test-output-buffered-file)
652 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
658
659 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-arg/0")
660 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-arg/1")
661 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-arg/2")
662 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-arg/3")
663 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-arg/4")
664 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-arg/5")
665 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-arg/6")
666 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-arg/7")
667
668 89/<- %esp 5/r32/ebp
669 5d/pop-to-ebp
670 c3/return
671
672 test-function-with-redefined-name:
673
674 55/push-ebp
675 89/<- %ebp 4/r32/esp
676
677 (clear-stream _test-input-stream)
678 (clear-stream $_test-input-buffered-file->buffer)
679 (clear-stream _test-output-stream)
680 (clear-stream $_test-output-buffered-file->buffer)
681 (clear-stream _test-error-stream)
682 (clear-stream $_test-error-buffered-file->buffer)
683
684 68/push 0/imm32
685 68/push 0/imm32
686 89/<- %edx 4/r32/esp
687 (tailor-exit-descriptor %edx 0x10)
688
689 (write _test-input-stream "fn foo {\n")
690 (write _test-input-stream "}\n")
691 (write _test-input-stream "fn foo {\n")
692 (write _test-input-stream "}\n")
693
694 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
695
696
697 89/<- %edx 4/r32/esp
698 (flush _test-output-buffered-file)
699 (flush _test-error-buffered-file)
700 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
706
707 (check-stream-equal _test-output-stream "" "F - test-function-with-redefined-name: output should be empty")
708 (check-next-stream-line-equal _test-error-stream "fn foo defined more than once" "F - test-function-with-redefined-name: error message")
709
710 (check-ints-equal *(edx+4) 2 "F - test-function-with-redefined-name: exit status")
711
712 81 0/subop/add %esp 8/imm32
713
714 5d/pop-to-ebp
715 c3/return
716
717 test-function-with-redefined-name-2:
718
719 55/push-ebp
720 89/<- %ebp 4/r32/esp
721
722 (clear-stream _test-input-stream)
723 (clear-stream $_test-input-buffered-file->buffer)
724 (clear-stream _test-output-stream)
725 (clear-stream $_test-output-buffered-file->buffer)
726 (clear-stream _test-error-stream)
727 (clear-stream $_test-error-buffered-file->buffer)
728
729 68/push 0/imm32
730 68/push 0/imm32
731 89/<- %edx 4/r32/esp
732 (tailor-exit-descriptor %edx 0x10)
733
734 (write _test-input-stream "fn foo {\n")
735 (write _test-input-stream "}\n")
736 (write _test-input-stream "sig foo\n")
737
738 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
739
740
741 89/<- %edx 4/r32/esp
742 (flush _test-output-buffered-file)
743 (flush _test-error-buffered-file)
744 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
750
751 (check-stream-equal _test-output-stream "" "F - test-function-with-redefined-name-2: output should be empty")
752 (check-next-stream-line-equal _test-error-stream "fn foo defined more than once" "F - test-function-with-redefined-name-2: error message")
753
754 (check-ints-equal *(edx+4) 2 "F - test-function-with-redefined-name-2: exit status")
755
756 81 0/subop/add %esp 8/imm32
757
758 5d/pop-to-ebp
759 c3/return
760
761 test-function-with-redefined-name-3:
762
763 55/push-ebp
764 89/<- %ebp 4/r32/esp
765
766 (clear-stream _test-input-stream)
767 (clear-stream $_test-input-buffered-file->buffer)
768 (clear-stream _test-output-stream)
769 (clear-stream $_test-output-buffered-file->buffer)
770 (clear-stream _test-error-stream)
771 (clear-stream $_test-error-buffered-file->buffer)
772
773 68/push 0/imm32
774 68/push 0/imm32
775 89/<- %edx 4/r32/esp
776 (tailor-exit-descriptor %edx 0x10)
777
778 (write _test-input-stream "sig foo\n")
779 (write _test-input-stream "fn foo {\n")
780 (write _test-input-stream "}\n")
781
782 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
783
784
785 89/<- %edx 4/r32/esp
786 (flush _test-output-buffered-file)
787 (flush _test-error-buffered-file)
788 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
794
795 (check-stream-equal _test-output-stream "" "F - test-function-with-redefined-name-3: output should be empty")
796 (check-next-stream-line-equal _test-error-stream "fn foo defined more than once" "F - test-function-with-redefined-name-3: error message")
797
798 (check-ints-equal *(edx+4) 2 "F - test-function-with-redefined-name-3: exit status")
799
800 81 0/subop/add %esp 8/imm32
801
802 5d/pop-to-ebp
803 c3/return
804
805 test-function-with-inout-in-register:
806
807 55/push-ebp
808 89/<- %ebp 4/r32/esp
809
810 (clear-stream _test-input-stream)
811 (clear-stream $_test-input-buffered-file->buffer)
812 (clear-stream _test-output-stream)
813 (clear-stream $_test-output-buffered-file->buffer)
814 (clear-stream _test-error-stream)
815 (clear-stream $_test-error-buffered-file->buffer)
816
817 68/push 0/imm32
818 68/push 0/imm32
819 89/<- %edx 4/r32/esp
820 (tailor-exit-descriptor %edx 0x10)
821
822 (write _test-input-stream "fn foo x/eax: int {\n")
823 (write _test-input-stream "}\n")
824
825 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
826
827
828 89/<- %edx 4/r32/esp
829 (flush _test-output-buffered-file)
830 (flush _test-error-buffered-file)
831 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
837
838 (check-stream-equal _test-output-stream "" "F - test-function-with-inout-in-register: output should be empty")
839 (check-next-stream-line-equal _test-error-stream "fn foo: function inout 'x' cannot be in a register" "F - test-function-with-inout-in-register: error message")
840
841 (check-ints-equal *(edx+4) 2 "F - test-function-with-inout-in-register: exit status")
842
843 81 0/subop/add %esp 8/imm32
844
845 5d/pop-to-ebp
846 c3/return
847
848 test-function-with-addr-output:
849
850 55/push-ebp
851 89/<- %ebp 4/r32/esp
852
853 (clear-stream _test-input-stream)
854 (clear-stream $_test-input-buffered-file->buffer)
855 (clear-stream _test-output-stream)
856 (clear-stream $_test-output-buffered-file->buffer)
857 (clear-stream _test-error-stream)
858 (clear-stream $_test-error-buffered-file->buffer)
859
860 68/push 0/imm32
861 68/push 0/imm32
862 89/<- %edx 4/r32/esp
863 (tailor-exit-descriptor %edx 0x10)
864
865 (write _test-input-stream "fn foo -> _/eax: (addr int) {\n")
866 (write _test-input-stream "}\n")
867
868 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
869
870
871 89/<- %edx 4/r32/esp
872 (flush _test-output-buffered-file)
873 (flush _test-error-buffered-file)
874 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
880
881 (check-stream-equal _test-output-stream "" "F - test-function-with-addr-output: output should be empty")
882 (check-next-stream-line-equal _test-error-stream "fn foo: output cannot have an addr type; that could allow unsafe addresses to escape the function" "F - test-function-with-addr-output: error message")
883
884 (check-ints-equal *(edx+4) 2 "F - test-function-with-addr-output: exit status")
885
886 81 0/subop/add %esp 8/imm32
887
888 5d/pop-to-ebp
889 c3/return
890
891 test-function-with-addr-inout:
892
893 55/push-ebp
894 89/<- %ebp 4/r32/esp
895
896 (clear-stream _test-input-stream)
897 (clear-stream $_test-input-buffered-file->buffer)
898 (clear-stream _test-output-stream)
899 (clear-stream $_test-output-buffered-file->buffer)
900 (clear-stream _test-error-stream)
901 (clear-stream $_test-error-buffered-file->buffer)
902
903 68/push 0/imm32
904 68/push 0/imm32
905 89/<- %edx 4/r32/esp
906 (tailor-exit-descriptor %edx 0x10)
907
908 (write _test-input-stream "fn foo a: (addr addr int) {\n")
909 (write _test-input-stream "}\n")
910
911 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
912
913
914 89/<- %edx 4/r32/esp
915 (flush _test-output-buffered-file)
916 (flush _test-error-buffered-file)
917 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
923
924 (check-stream-equal _test-output-stream "" "F - test-function-with-addr-inout: output should be empty")
925 (check-next-stream-line-equal _test-error-stream "fn foo: inout 'a' cannot contain 'addr' anywhere in the type except the first word; that could allow unsafe addresses to escape the function" "F - test-function-with-addr-inout: error message")
926
927 (check-ints-equal *(edx+4) 2 "F - test-function-with-addr-inout: exit status")
928
929 81 0/subop/add %esp 8/imm32
930
931 5d/pop-to-ebp
932 c3/return
933
934 test-function-with-addr-inout-2:
935
936 55/push-ebp
937 89/<- %ebp 4/r32/esp
938
939 (clear-stream _test-input-stream)
940 (clear-stream $_test-input-buffered-file->buffer)
941 (clear-stream _test-output-stream)
942 (clear-stream $_test-output-buffered-file->buffer)
943 (clear-stream _test-error-stream)
944 (clear-stream $_test-error-buffered-file->buffer)
945
946 68/push 0/imm32
947 68/push 0/imm32
948 89/<- %edx 4/r32/esp
949 (tailor-exit-descriptor %edx 0x10)
950
951 (write _test-input-stream "fn foo a: (addr array addr int) {\n")
952 (write _test-input-stream "}\n")
953
954 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
955
956
957 89/<- %edx 4/r32/esp
958 (flush _test-output-buffered-file)
959 (flush _test-error-buffered-file)
960 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
966
967 (check-stream-equal _test-output-stream "" "F - test-function-with-addr-inout-2: output should be empty")
968 (check-next-stream-line-equal _test-error-stream "fn foo: inout 'a' cannot contain 'addr' anywhere in the type except the first word; that could allow unsafe addresses to escape the function" "F - test-function-with-addr-inout-2: error message")
969
970 (check-ints-equal *(edx+4) 2 "F - test-function-with-addr-inout-2: exit status")
971
972 81 0/subop/add %esp 8/imm32
973
974 5d/pop-to-ebp
975 c3/return
976
977 test-function-with-addr-inout-3:
978
979 55/push-ebp
980 89/<- %ebp 4/r32/esp
981
982 (clear-stream _test-input-stream)
983 (clear-stream $_test-input-buffered-file->buffer)
984 (clear-stream _test-output-stream)
985 (clear-stream $_test-output-buffered-file->buffer)
986 (clear-stream _test-error-stream)
987 (clear-stream $_test-error-buffered-file->buffer)
988
989 68/push 0/imm32
990 68/push 0/imm32
991 89/<- %edx 4/r32/esp
992 (tailor-exit-descriptor %edx 0x10)
993
994 (write _test-input-stream "fn foo a: (addr array (addr int) 3) {\n")
995 (write _test-input-stream "}\n")
996
997 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
998
999
1000 89/<- %edx 4/r32/esp
1001 (flush _test-output-buffered-file)
1002 (flush _test-error-buffered-file)
1003 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
1009
1010 (check-stream-equal _test-output-stream "" "F - test-function-with-addr-inout-3: output should be empty")
1011 (check-next-stream-line-equal _test-error-stream "fn foo: inout 'a' cannot contain 'addr' anywhere in the type except the first word; that could allow unsafe addresses to escape the function" "F - test-function-with-addr-inout-3: error message")
1012
1013 (check-ints-equal *(edx+4) 2 "F - test-function-with-addr-inout-3: exit status")
1014
1015 81 0/subop/add %esp 8/imm32
1016
1017 5d/pop-to-ebp
1018 c3/return
1019
1020 test-function-with-addr-inout-4:
1021
1022 55/push-ebp
1023 89/<- %ebp 4/r32/esp
1024
1025 (clear-stream _test-input-stream)
1026 (clear-stream $_test-input-buffered-file->buffer)
1027 (clear-stream _test-output-stream)
1028 (clear-stream $_test-output-buffered-file->buffer)
1029 (clear-stream _test-error-stream)
1030 (clear-stream $_test-error-buffered-file->buffer)
1031
1032 68/push 0/imm32
1033 68/push 0/imm32
1034 89/<- %edx 4/r32/esp
1035 (tailor-exit-descriptor %edx 0x10)
1036
1037 (write _test-input-stream "fn foo a: (array (addr int) 3) {\n")
1038 (write _test-input-stream "}\n")
1039
1040 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
1041
1042
1043 89/<- %edx 4/r32/esp
1044 (flush _test-output-buffered-file)
1045 (flush _test-error-buffered-file)
1046 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
1052
1053 (check-stream-equal _test-output-stream "" "F - test-function-with-addr-inout-4: output should be empty")
1054 (check-next-stream-line-equal _test-error-stream "fn foo: inout 'a' cannot contain 'addr' anywhere in the type except the first word; that could allow unsafe addresses to escape the function" "F - test-function-with-addr-inout-4: error message")
1055
1056 (check-ints-equal *(edx+4) 2 "F - test-function-with-addr-inout-4: exit status")
1057
1058 81 0/subop/add %esp 8/imm32
1059
1060 5d/pop-to-ebp
1061 c3/return
1062
1063
1064 test-function-main-with-addr-inout:
1065
1066 55/push-ebp
1067 89/<- %ebp 4/r32/esp
1068
1069 (clear-stream _test-input-stream)
1070 (clear-stream $_test-input-buffered-file->buffer)
1071 (clear-stream _test-output-stream)
1072 (clear-stream $_test-output-buffered-file->buffer)
1073
1074 (write _test-input-stream "fn main a: (addr addr int) {\n")
1075 (write _test-input-stream "}\n")
1076
1077 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
1078 (flush _test-output-buffered-file)
1079
1080
1081 89/<- %esp 5/r32/ebp
1082 5d/pop-to-ebp
1083 c3/return
1084
1085
1086 test-signature-lookup-with-addr-inout:
1087
1088 55/push-ebp
1089 89/<- %ebp 4/r32/esp
1090
1091 (clear-stream _test-input-stream)
1092 (clear-stream $_test-input-buffered-file->buffer)
1093 (clear-stream _test-output-stream)
1094 (clear-stream $_test-output-buffered-file->buffer)
1095
1096 (write _test-input-stream "sig lookup h: (handle _T) -> _/eax: (addr _T)\n")
1097
1098 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
1099 (flush _test-output-buffered-file)
1100
1101
1102 89/<- %esp 5/r32/ebp
1103 5d/pop-to-ebp
1104 c3/return
1105
1106 test-convert-function-with-arg-and-body:
1107
1108 55/push-ebp
1109 89/<- %ebp 4/r32/esp
1110
1111 (clear-stream _test-input-stream)
1112 (clear-stream $_test-input-buffered-file->buffer)
1113 (clear-stream _test-output-stream)
1114 (clear-stream $_test-output-buffered-file->buffer)
1115
1116 (write _test-input-stream "fn foo n: int {\n")
1117 (write _test-input-stream " increment n\n")
1118 (write _test-input-stream "}\n")
1119
1120 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
1121 (flush _test-output-buffered-file)
1122 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
1128
1129 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-arg-and-body/0")
1130 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-arg-and-body/1")
1131 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-arg-and-body/2")
1132 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-arg-and-body/3")
1133 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-arg-and-body/4")
1134 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-arg-and-body/5")
1135 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-arg-and-body/6")
1136 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-arg-and-body/7")
1137 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-arg-and-body/8")
1138 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-arg-and-body/9")
1139 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-arg-and-body/10")
1140 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-arg-and-body/11")
1141 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-arg-and-body/12")
1142
1143 89/<- %esp 5/r32/ebp
1144 5d/pop-to-ebp
1145 c3/return
1146
1147 test-convert-function-distinguishes-args:
1148
1149 55/push-ebp
1150 89/<- %ebp 4/r32/esp
1151
1152 (clear-stream _test-input-stream)
1153 (clear-stream $_test-input-buffered-file->buffer)
1154 (clear-stream _test-output-stream)
1155 (clear-stream $_test-output-buffered-file->buffer)
1156
1157 (write _test-input-stream "fn foo a: int, b: int {\n")
1158 (write _test-input-stream " increment b\n")
1159 (write _test-input-stream "}\n")
1160
1161 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
1162 (flush _test-output-buffered-file)
1163 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
1169
1170 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-distinguishes-args/0")
1171 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-distinguishes-args/1")
1172 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-distinguishes-args/2")
1173 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-distinguishes-args/3")
1174 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-distinguishes-args/4")
1175 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-distinguishes-args/5")
1176 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x0000000c)" "F - test-convert-function-distinguishes-args/6")
1177 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-distinguishes-args/7")
1178 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-distinguishes-args/8")
1179 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-distinguishes-args/9")
1180 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-distinguishes-args/10")
1181 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-distinguishes-args/11")
1182 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-distinguishes-args/12")
1183
1184 89/<- %esp 5/r32/ebp
1185 5d/pop-to-ebp
1186 c3/return
1187
1188 test-convert-function-with-return-literal:
1189
1190 55/push-ebp
1191 89/<- %ebp 4/r32/esp
1192
1193 (clear-stream _test-input-stream)
1194 (clear-stream $_test-input-buffered-file->buffer)
1195 (clear-stream _test-output-stream)
1196 (clear-stream $_test-output-buffered-file->buffer)
1197
1198 (write _test-input-stream "fn foo -> _/eax: int {\n")
1199 (write _test-input-stream " return 0\n")
1200 (write _test-input-stream "}\n")
1201
1202 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
1203 (flush _test-output-buffered-file)
1204 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
1210
1211 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-literal/0")
1212 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-literal/1")
1213 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-literal/2")
1214 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-literal/3")
1215 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-literal/4")
1216 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-literal/5")
1217 (check-next-stream-line-equal _test-output-stream " c7 0/subop/copy %eax 0/imm32" "F - test-convert-function-with-return-literal/6")
1218 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-literal/7")
1219 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-literal/8")
1220 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-literal/9")
1221 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-literal/10")
1222 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-literal/11")
1223 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-literal/12")
1224 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-literal/13")
1225
1226 89/<- %esp 5/r32/ebp
1227 5d/pop-to-ebp
1228 c3/return
1229
1230 test-convert-function-with-return:
1231
1232 55/push-ebp
1233 89/<- %ebp 4/r32/esp
1234
1235 (clear-stream _test-input-stream)
1236 (clear-stream $_test-input-buffered-file->buffer)
1237 (clear-stream _test-output-stream)
1238 (clear-stream $_test-output-buffered-file->buffer)
1239
1240 (write _test-input-stream "fn foo -> _/eax: int {\n")
1241 (write _test-input-stream " var y: int\n")
1242 (write _test-input-stream " return y\n")
1243 (write _test-input-stream "}\n")
1244
1245 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
1246 (flush _test-output-buffered-file)
1247 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
1253
1254 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return/0")
1255 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return/1")
1256 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return/2")
1257 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return/3")
1258 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return/4")
1259 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return/5")
1260 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-return/6")
1261 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0xfffffffc) 0x00000000/r32" "F - test-convert-function-with-return/7")
1262 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-return/8")
1263 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return/9")
1264 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return/10")
1265 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return/11")
1266 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return/12")
1267 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return/13")
1268 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return/14")
1269 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return/15")
1270
1271 89/<- %esp 5/r32/ebp
1272 5d/pop-to-ebp
1273 c3/return
1274
1275 test-convert-function-with-return-register:
1276
1277 55/push-ebp
1278 89/<- %ebp 4/r32/esp
1279
1280 (clear-stream _test-input-stream)
1281 (clear-stream $_test-input-buffered-file->buffer)
1282 (clear-stream _test-output-stream)
1283 (clear-stream $_test-output-buffered-file->buffer)
1284
1285 (write _test-input-stream "fn foo -> _/eax: int {\n")
1286 (write _test-input-stream " var y/eax: int <- copy 3\n")
1287 (write _test-input-stream " return y\n")
1288 (write _test-input-stream "}\n")
1289
1290 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
1291 (flush _test-output-buffered-file)
1292 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
1298
1299 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-register/0")
1300 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-register/1")
1301 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-register/2")
1302 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-register/3")
1303 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-register/4")
1304 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-register/5")
1305 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-return-register/6")
1306 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-convert-function-with-return-register/7")
1307 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-function-with-return-register/8")
1308 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-return-register/9")
1309 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-register/10")
1310 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-register/11")
1311 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-register/12")
1312 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-register/13")
1313 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-register/14")
1314 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-register/15")
1315 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-register/16")
1316
1317 89/<- %esp 5/r32/ebp
1318 5d/pop-to-ebp
1319 c3/return
1320
1321 test-function-with-output-without-register:
1322
1323 55/push-ebp
1324 89/<- %ebp 4/r32/esp
1325
1326 (clear-stream _test-input-stream)
1327 (clear-stream $_test-input-buffered-file->buffer)
1328 (clear-stream _test-output-stream)
1329 (clear-stream $_test-output-buffered-file->buffer)
1330 (clear-stream _test-error-stream)
1331 (clear-stream $_test-error-buffered-file->buffer)
1332
1333 68/push 0/imm32
1334 68/push 0/imm32
1335 89/<- %edx 4/r32/esp
1336 (tailor-exit-descriptor %edx 0x10)
1337
1338 (write _test-input-stream "fn foo -> _: int {\n")
1339 (write _test-input-stream "}\n")
1340
1341 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
1342
1343
1344 89/<- %edx 4/r32/esp
1345 (flush _test-output-buffered-file)
1346 (flush _test-error-buffered-file)
1347 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
1353
1354 (check-stream-equal _test-output-stream "" "F - test-function-with-output-without-register: output should be empty")
1355 (check-next-stream-line-equal _test-error-stream "fn foo: function output '_' must be in a register, in instruction 'fn foo -> _: int {" "F - test-function-with-output-without-register: error message")
1356
1357 (check-ints-equal *(edx+4) 2 "F - test-function-with-output-without-register: exit status")
1358
1359 81 0/subop/add %esp 8/imm32
1360
1361 5d/pop-to-ebp
1362 c3/return
1363
1364 test-function-with-outputs-in-conflicting-registers:
1365
1366 55/push-ebp
1367 89/<- %ebp 4/r32/esp
1368
1369 (clear-stream _test-input-stream)
1370 (clear-stream $_test-input-buffered-file->buffer)
1371 (clear-stream _test-output-stream)
1372 (clear-stream $_test-output-buffered-file->buffer)
1373 (clear-stream _test-error-stream)
1374 (clear-stream $_test-error-buffered-file->buffer)
1375
1376 68/push 0/imm32
1377 68/push 0/imm32
1378 89/<- %edx 4/r32/esp
1379 (tailor-exit-descriptor %edx 0x10)
1380
1381 (write _test-input-stream "fn foo -> _/eax: int, _/eax: int {\n")
1382 (write _test-input-stream "}\n")
1383
1384 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
1385
1386
1387 89/<- %edx 4/r32/esp
1388 (flush _test-output-buffered-file)
1389 (flush _test-error-buffered-file)
1390 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
1396
1397 (check-stream-equal _test-output-stream "" "F - test-function-with-outputs-in-conflicting-registers: output should be empty")
1398 (check-next-stream-line-equal _test-error-stream "fn foo: outputs must be in unique registers" "F - test-function-with-outputs-in-conflicting-registers: error message")
1399
1400 (check-ints-equal *(edx+4) 2 "F - test-function-with-outputs-in-conflicting-registers: exit status")
1401
1402 81 0/subop/add %esp 8/imm32
1403
1404 5d/pop-to-ebp
1405 c3/return
1406
1407 test-function-with-named-output:
1408
1409 55/push-ebp
1410 89/<- %ebp 4/r32/esp
1411
1412 (clear-stream _test-input-stream)
1413 (clear-stream $_test-input-buffered-file->buffer)
1414 (clear-stream _test-output-stream)
1415 (clear-stream $_test-output-buffered-file->buffer)
1416 (clear-stream _test-error-stream)
1417 (clear-stream $_test-error-buffered-file->buffer)
1418
1419 68/push 0/imm32
1420 68/push 0/imm32
1421 89/<- %edx 4/r32/esp
1422 (tailor-exit-descriptor %edx 0x10)
1423
1424 (write _test-input-stream "fn foo -> x/eax: int {\n")
1425 (write _test-input-stream " return 0\n")
1426 (write _test-input-stream "}\n")
1427
1428 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
1429
1430
1431 89/<- %edx 4/r32/esp
1432 (flush _test-output-buffered-file)
1433 (flush _test-error-buffered-file)
1434 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
1440
1441 (check-stream-equal _test-output-stream "" "F - test-function-with-named-output: output should be empty")
1442 (check-next-stream-line-equal _test-error-stream "fn foo: function outputs cannot be named; rename 'x' in the header to '_'" "F - test-function-with-named-output: error message")
1443
1444 (check-ints-equal *(edx+4) 2 "F - test-function-with-named-output: exit status")
1445
1446 81 0/subop/add %esp 8/imm32
1447
1448 5d/pop-to-ebp
1449 c3/return
1450
1451 test-return-with-wrong-type:
1452
1453 55/push-ebp
1454 89/<- %ebp 4/r32/esp
1455
1456 (clear-stream _test-input-stream)
1457 (clear-stream $_test-input-buffered-file->buffer)
1458 (clear-stream _test-output-stream)
1459 (clear-stream $_test-output-buffered-file->buffer)
1460 (clear-stream _test-error-stream)
1461 (clear-stream $_test-error-buffered-file->buffer)
1462
1463 68/push 0/imm32
1464 68/push 0/imm32
1465 89/<- %edx 4/r32/esp
1466 (tailor-exit-descriptor %edx 0x10)
1467
1468 (write _test-input-stream "fn foo -> _/eax: int {\n")
1469 (write _test-input-stream " var x/eax: boolean <- copy 0\n")
1470 (write _test-input-stream " return x\n")
1471 (write _test-input-stream "}\n")
1472
1473 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
1474
1475
1476 89/<- %edx 4/r32/esp
1477 (flush _test-output-buffered-file)
1478 (flush _test-error-buffered-file)
1479 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
1485
1486 (check-stream-equal _test-output-stream "" "F - test-return-with-wrong-type: output should be empty")
1487 (check-next-stream-line-equal _test-error-stream "fn foo: return: 'x' has the wrong type" "F - test-return-with-wrong-type: error message")
1488
1489 (check-ints-equal *(edx+4) 2 "F - test-return-with-wrong-type: exit status")
1490
1491 81 0/subop/add %esp 8/imm32
1492
1493 5d/pop-to-ebp
1494 c3/return
1495
1496 test-missing-return:
1497
1498 55/push-ebp
1499 89/<- %ebp 4/r32/esp
1500
1501 (clear-stream _test-input-stream)
1502 (clear-stream $_test-input-buffered-file->buffer)
1503 (clear-stream _test-output-stream)
1504 (clear-stream $_test-output-buffered-file->buffer)
1505 (clear-stream _test-error-stream)
1506 (clear-stream $_test-error-buffered-file->buffer)
1507
1508 68/push 0/imm32
1509 68/push 0/imm32
1510 89/<- %edx 4/r32/esp
1511 (tailor-exit-descriptor %edx 0x10)
1512
1513 (write _test-input-stream "fn foo -> _/eax: int {\n")
1514 (write _test-input-stream " var x/eax: boolean <- copy 0\n")
1515 (write _test-input-stream "}\n")
1516
1517 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
1518
1519
1520 89/<- %edx 4/r32/esp
1521 (flush _test-output-buffered-file)
1522 (flush _test-error-buffered-file)
1523 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
1529
1530 (check-stream-equal _test-output-stream "" "F - test-missing-return: output should be empty")
1531 (check-next-stream-line-equal _test-error-stream "fn foo: final statement should be a 'return'" "F - test-missing-return: error message")
1532
1533 (check-ints-equal *(edx+4) 2 "F - test-missing-return: exit status")
1534
1535 81 0/subop/add %esp 8/imm32
1536
1537 5d/pop-to-ebp
1538 c3/return
1539
1540 test-early-exit-without-return:
1541
1542 55/push-ebp
1543 89/<- %ebp 4/r32/esp
1544
1545 (clear-stream _test-input-stream)
1546 (clear-stream $_test-input-buffered-file->buffer)
1547 (clear-stream _test-output-stream)
1548 (clear-stream $_test-output-buffered-file->buffer)
1549 (clear-stream _test-error-stream)
1550 (clear-stream $_test-error-buffered-file->buffer)
1551
1552 68/push 0/imm32
1553 68/push 0/imm32
1554 89/<- %edx 4/r32/esp
1555 (tailor-exit-descriptor %edx 0x10)
1556
1557 (write _test-input-stream "fn foo -> _/eax: int {\n")
1558 (write _test-input-stream " break\n")
1559 (write _test-input-stream " return 0\n")
1560 (write _test-input-stream "}\n")
1561
1562 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
1563
1564
1565 89/<- %edx 4/r32/esp
1566 (flush _test-output-buffered-file)
1567 (flush _test-error-buffered-file)
1568 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
1574
1575 (check-stream-equal _test-output-stream "" "F - test-early-exit-without-return: output should be empty")
1576 (check-next-stream-line-equal _test-error-stream "fn foo has outputs, so you cannot 'break' out of the outermost block. Use 'return'." "F - test-early-exit-without-return: error message")
1577
1578 (check-ints-equal *(edx+4) 2 "F - test-early-exit-without-return: exit status")
1579
1580 81 0/subop/add %esp 8/imm32
1581
1582 5d/pop-to-ebp
1583 c3/return
1584
1585 test-return-with-too-few-inouts:
1586
1587 55/push-ebp
1588 89/<- %ebp 4/r32/esp
1589
1590 (clear-stream _test-input-stream)
1591 (clear-stream $_test-input-buffered-file->buffer)
1592 (clear-stream _test-output-stream)
1593 (clear-stream $_test-output-buffered-file->buffer)
1594 (clear-stream _test-error-stream)
1595 (clear-stream $_test-error-buffered-file->buffer)
1596
1597 68/push 0/imm32
1598 68/push 0/imm32
1599 89/<- %edx 4/r32/esp
1600 (tailor-exit-descriptor %edx 0x10)
1601
1602 (write _test-input-stream "fn foo -> _/eax: int {\n")
1603 (write _test-input-stream " return\n")
1604 (write _test-input-stream "}\n")
1605
1606 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
1607
1608
1609 89/<- %edx 4/r32/esp
1610 (flush _test-output-buffered-file)
1611 (flush _test-error-buffered-file)
1612 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
1618
1619 (check-stream-equal _test-output-stream "" "F - test-return-with-too-few-inouts: output should be empty")
1620 (check-next-stream-line-equal _test-error-stream "fn foo: return: too few inouts" "F - test-return-with-too-few-inouts: error message")
1621
1622 (check-ints-equal *(edx+4) 2 "F - test-return-with-too-few-inouts: exit status")
1623
1624 81 0/subop/add %esp 8/imm32
1625
1626 5d/pop-to-ebp
1627 c3/return
1628
1629 test-return-with-too-many-inouts:
1630
1631 55/push-ebp
1632 89/<- %ebp 4/r32/esp
1633
1634 (clear-stream _test-input-stream)
1635 (clear-stream $_test-input-buffered-file->buffer)
1636 (clear-stream _test-output-stream)
1637 (clear-stream $_test-output-buffered-file->buffer)
1638 (clear-stream _test-error-stream)
1639 (clear-stream $_test-error-buffered-file->buffer)
1640
1641 68/push 0/imm32
1642 68/push 0/imm32
1643 89/<- %edx 4/r32/esp
1644 (tailor-exit-descriptor %edx 0x10)
1645
1646 (write _test-input-stream "fn foo -> _/eax: int {\n")
1647 (write _test-input-stream " return 0, 0\n")
1648 (write _test-input-stream "}\n")
1649
1650 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
1651
1652
1653 89/<- %edx 4/r32/esp
1654 (flush _test-output-buffered-file)
1655 (flush _test-error-buffered-file)
1656 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
1662
1663 (check-stream-equal _test-output-stream "" "F - test-return-with-too-many-inouts: output should be empty")
1664 (check-next-stream-line-equal _test-error-stream "fn foo: return: too many inouts" "F - test-return-with-too-many-inouts: error message")
1665
1666 (check-ints-equal *(edx+4) 2 "F - test-return-with-too-many-inouts: exit status")
1667
1668 81 0/subop/add %esp 8/imm32
1669
1670 5d/pop-to-ebp
1671 c3/return
1672
1673 test-return-unavailable-value:
1674
1675 55/push-ebp
1676 89/<- %ebp 4/r32/esp
1677
1678 (clear-stream _test-input-stream)
1679 (clear-stream $_test-input-buffered-file->buffer)
1680 (clear-stream _test-output-stream)
1681 (clear-stream $_test-output-buffered-file->buffer)
1682 (clear-stream _test-error-stream)
1683 (clear-stream $_test-error-buffered-file->buffer)
1684
1685 68/push 0/imm32
1686 68/push 0/imm32
1687 89/<- %edx 4/r32/esp
1688 (tailor-exit-descriptor %edx 0x10)
1689
1690 (write _test-input-stream "fn foo -> _/eax: int, _/ecx: int {\n")
1691 (write _test-input-stream " var x/eax: int <- copy 0\n")
1692 (write _test-input-stream " var y/ecx: int <- copy 0\n")
1693 (write _test-input-stream " return y, x\n")
1694 (write _test-input-stream "}\n")
1695
1696 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
1697
1698
1699 89/<- %edx 4/r32/esp
1700 (flush _test-output-buffered-file)
1701 (flush _test-error-buffered-file)
1702 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
1708
1709 (check-stream-equal _test-output-stream "" "F - test-return-unavailable-value: output should be empty")
1710 (check-next-stream-line-equal _test-error-stream "fn foo: return: 'x' is no longer available" "F - test-return-unavailable-value: error message")
1711
1712 (check-ints-equal *(edx+4) 2 "F - test-return-unavailable-value: exit status")
1713
1714 81 0/subop/add %esp 8/imm32
1715
1716 5d/pop-to-ebp
1717 c3/return
1718
1719 test-convert-return-with-duplicate-values:
1720
1721 55/push-ebp
1722 89/<- %ebp 4/r32/esp
1723
1724 (clear-stream _test-input-stream)
1725 (clear-stream $_test-input-buffered-file->buffer)
1726 (clear-stream _test-output-stream)
1727 (clear-stream $_test-output-buffered-file->buffer)
1728
1729 (write _test-input-stream "fn foo -> _/eax: int, _/ecx: int {\n")
1730 (write _test-input-stream " var x/eax: int <- copy 0x34\n")
1731 (write _test-input-stream " return x, x\n")
1732 (write _test-input-stream "}\n")
1733
1734 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
1735 (flush _test-output-buffered-file)
1736 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
1742
1743 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-return-with-duplicate-values/0")
1744 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-return-with-duplicate-values/1")
1745 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-return-with-duplicate-values/2")
1746 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-return-with-duplicate-values/3")
1747 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-return-with-duplicate-values/4")
1748 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-return-with-duplicate-values/5")
1749 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-return-with-duplicate-values/6")
1750 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0x34/imm32" "F - test-convert-return-with-duplicate-values/7")
1751 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-return-with-duplicate-values/8")
1752 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000001/r32" "F - test-convert-return-with-duplicate-values/9")
1753 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-return-with-duplicate-values/10")
1754 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-return-with-duplicate-values/11")
1755 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-return-with-duplicate-values/12")
1756 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-return-with-duplicate-values/13")
1757 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-return-with-duplicate-values/14")
1758 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-return-with-duplicate-values/15")
1759 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-return-with-duplicate-values/16")
1760 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-return-with-duplicate-values/17")
1761
1762 89/<- %esp 5/r32/ebp
1763 5d/pop-to-ebp
1764 c3/return
1765
1766 test-convert-return-with-duplicate-values-2:
1767
1768 55/push-ebp
1769 89/<- %ebp 4/r32/esp
1770
1771 (clear-stream _test-input-stream)
1772 (clear-stream $_test-input-buffered-file->buffer)
1773 (clear-stream _test-output-stream)
1774 (clear-stream $_test-output-buffered-file->buffer)
1775
1776 (write _test-input-stream "fn foo -> _/eax: int, _/ecx: int {\n")
1777 (write _test-input-stream " var x/ecx: int <- copy 0x34\n")
1778 (write _test-input-stream " return x, x\n")
1779 (write _test-input-stream "}\n")
1780
1781 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
1782 (flush _test-output-buffered-file)
1783 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
1789
1790 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-return-with-duplicate-values-2/0")
1791 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-return-with-duplicate-values-2/1")
1792 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-return-with-duplicate-values-2/2")
1793 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-return-with-duplicate-values-2/3")
1794 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-return-with-duplicate-values-2/4")
1795 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-return-with-duplicate-values-2/5")
1796 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-return-with-duplicate-values-2/6")
1797 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x34/imm32" "F - test-convert-return-with-duplicate-values-2/7")
1798 (check-next-stream-line-equal _test-output-stream " 8b/-> %ecx 0x00000000/r32" "F - test-convert-return-with-duplicate-values-2/8")
1799 (check-next-stream-line-equal _test-output-stream " 8b/-> %ecx 0x00000001/r32" "F - test-convert-return-with-duplicate-values-2/9")
1800 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-return-with-duplicate-values-2/10")
1801 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-return-with-duplicate-values-2/11")
1802 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-return-with-duplicate-values-2/12")
1803 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-return-with-duplicate-values-2/13")
1804 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-return-with-duplicate-values-2/14")
1805 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-return-with-duplicate-values-2/15")
1806 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-return-with-duplicate-values-2/16")
1807 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-return-with-duplicate-values-2/17")
1808
1809 89/<- %esp 5/r32/ebp
1810 5d/pop-to-ebp
1811 c3/return
1812
1813 test-stmt-with-unknown-var:
1814
1815 55/push-ebp
1816 89/<- %ebp 4/r32/esp
1817
1818 (clear-stream _test-input-stream)
1819 (clear-stream $_test-input-buffered-file->buffer)
1820 (clear-stream _test-output-stream)
1821 (clear-stream $_test-output-buffered-file->buffer)
1822 (clear-stream _test-error-stream)
1823 (clear-stream $_test-error-buffered-file->buffer)
1824
1825 68/push 0/imm32
1826 68/push 0/imm32
1827 89/<- %edx 4/r32/esp
1828 (tailor-exit-descriptor %edx 0x10)
1829
1830 (write _test-input-stream "fn foo {\n")
1831 (write _test-input-stream " x <- copy 0x34\n")
1832 (write _test-input-stream "}\n")
1833
1834 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
1835
1836
1837 89/<- %edx 4/r32/esp
1838 (flush _test-output-buffered-file)
1839 (flush _test-error-buffered-file)
1840 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
1846
1847 (check-stream-equal _test-output-stream "" "F - test-stmt-with-unknown-var: output should be empty")
1848 (check-next-stream-line-equal _test-error-stream "fn foo: unknown variable 'x'" "F - test-stmt-with-unknown-var: error message")
1849
1850 (check-ints-equal *(edx+4) 2 "F - test-stmt-with-unknown-var: exit status")
1851
1852 81 0/subop/add %esp 8/imm32
1853
1854 5d/pop-to-ebp
1855 c3/return
1856
1857 test-stmt-with-invalid-identifier:
1858
1859 55/push-ebp
1860 89/<- %ebp 4/r32/esp
1861
1862 (clear-stream _test-input-stream)
1863 (clear-stream $_test-input-buffered-file->buffer)
1864 (clear-stream _test-output-stream)
1865 (clear-stream $_test-output-buffered-file->buffer)
1866 (clear-stream _test-error-stream)
1867 (clear-stream $_test-error-buffered-file->buffer)
1868
1869 68/push 0/imm32
1870 68/push 0/imm32
1871 89/<- %edx 4/r32/esp
1872 (tailor-exit-descriptor %edx 0x10)
1873
1874 (write _test-input-stream "fn foo {\n")
1875 (write _test-input-stream " 1 <- copy 0x34\n")
1876 (write _test-input-stream "}\n")
1877
1878 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
1879
1880
1881 89/<- %edx 4/r32/esp
1882 (flush _test-output-buffered-file)
1883 (flush _test-error-buffered-file)
1884 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
1890
1891 (check-stream-equal _test-output-stream "" "F - test-stmt-with-invalid-identifier: output should be empty")
1892 (check-next-stream-line-equal _test-error-stream "fn foo: invalid identifier '1'" "F - test-stmt-with-invalid-identifier: error message")
1893
1894 (check-ints-equal *(edx+4) 2 "F - test-stmt-with-invalid-identifier: exit status")
1895
1896 81 0/subop/add %esp 8/imm32
1897
1898 5d/pop-to-ebp
1899 c3/return
1900
1901 test-stmt-with-deref-var:
1902
1903 55/push-ebp
1904 89/<- %ebp 4/r32/esp
1905
1906 (clear-stream _test-input-stream)
1907 (clear-stream $_test-input-buffered-file->buffer)
1908 (clear-stream _test-output-stream)
1909 (clear-stream $_test-output-buffered-file->buffer)
1910 (clear-stream _test-error-stream)
1911 (clear-stream $_test-error-buffered-file->buffer)
1912
1913 68/push 0/imm32
1914 68/push 0/imm32
1915 89/<- %edx 4/r32/esp
1916 (tailor-exit-descriptor %edx 0x10)
1917
1918 (write _test-input-stream "fn foo {\n")
1919 (write _test-input-stream " *x <- copy 0x34\n")
1920 (write _test-input-stream "}\n")
1921
1922 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
1923
1924
1925 89/<- %edx 4/r32/esp
1926 (flush _test-output-buffered-file)
1927 (flush _test-error-buffered-file)
1928 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
1934
1935 (check-stream-equal _test-output-stream "" "F - test-stmt-with-deref-var: output should be empty")
1936 (check-next-stream-line-equal _test-error-stream "fn foo: output '*x' should write to a register, and therefore cannot be dereferenced" "F - test-stmt-with-deref-var: error message")
1937
1938 (check-ints-equal *(edx+4) 2 "F - test-stmt-with-deref-var: exit status")
1939
1940 81 0/subop/add %esp 8/imm32
1941
1942 5d/pop-to-ebp
1943 c3/return
1944
1945 test-convert-function-with-literal-arg:
1946
1947 55/push-ebp
1948 89/<- %ebp 4/r32/esp
1949
1950 (clear-stream _test-input-stream)
1951 (clear-stream $_test-input-buffered-file->buffer)
1952 (clear-stream _test-output-stream)
1953 (clear-stream $_test-output-buffered-file->buffer)
1954
1955 (write _test-input-stream "fn foo a: int, b: int -> _/eax: int {\n")
1956 (write _test-input-stream " var result/eax: int <- copy a\n")
1957 (write _test-input-stream " result <- add 1\n")
1958 (write _test-input-stream " return result\n")
1959 (write _test-input-stream "}\n")
1960
1961 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
1962 (flush _test-output-buffered-file)
1963 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
1969
1970 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-literal-arg/0")
1971 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-literal-arg/1")
1972 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-literal-arg/2")
1973 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-literal-arg/3")
1974 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-literal-arg/4")
1975 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-literal-arg/5")
1976 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-literal-arg/6")
1977 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-function-with-literal-arg/7")
1978 (check-next-stream-line-equal _test-output-stream " 05/add-to-eax 1/imm32" "F - test-convert-function-with-literal-arg/8")
1979 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-function-with-literal-arg/9")
1980 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-literal-arg/10")
1981 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-literal-arg/11")
1982 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-literal-arg/12")
1983 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-literal-arg/13")
1984 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-literal-arg/14")
1985 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-literal-arg/15")
1986 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-literal-arg/16")
1987 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-literal-arg/17")
1988
1989 89/<- %esp 5/r32/ebp
1990 5d/pop-to-ebp
1991 c3/return
1992
1993 test-convert-function-with-literal-arg-2:
1994
1995 55/push-ebp
1996 89/<- %ebp 4/r32/esp
1997
1998 (clear-stream _test-input-stream)
1999 (clear-stream $_test-input-buffered-file->buffer)
2000 (clear-stream _test-output-stream)
2001 (clear-stream $_test-output-buffered-file->buffer)
2002
2003 (write _test-input-stream "fn foo a: int, b: int -> _/ebx: int {\n")
2004 (write _test-input-stream " var result/ebx: int <- copy a\n")
2005 (write _test-input-stream " result <- add 1\n")
2006 (write _test-input-stream " return result\n")
2007 (write _test-input-stream "}\n")
2008
2009 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
2010 (flush _test-output-buffered-file)
2011 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
2017
2018 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-literal-arg-2/0")
2019 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-literal-arg-2/1")
2020 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-literal-arg-2/2")
2021 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-literal-arg-2/3")
2022 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-literal-arg-2/4")
2023 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-literal-arg-2/5")
2024 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ebx" "F - test-convert-function-with-literal-arg-2/6")
2025 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000003/r32" "F - test-convert-function-with-literal-arg-2/7")
2026 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %ebx 1/imm32" "F - test-convert-function-with-literal-arg-2/8")
2027 (check-next-stream-line-equal _test-output-stream " 8b/-> %ebx 0x00000003/r32" "F - test-convert-function-with-literal-arg-2/9")
2028 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-literal-arg-2/10")
2029 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-literal-arg-2/11")
2030 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-literal-arg-2/12")
2031 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-literal-arg-2/13")
2032 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-literal-arg-2/14")
2033 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-literal-arg-2/15")
2034 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-literal-arg-2/16")
2035 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-literal-arg-2/17")
2036
2037 89/<- %esp 5/r32/ebp
2038 5d/pop-to-ebp
2039 c3/return
2040
2041 test-convert-function-call-with-literal-arg:
2042
2043 55/push-ebp
2044 89/<- %ebp 4/r32/esp
2045
2046 (clear-stream _test-input-stream)
2047 (clear-stream $_test-input-buffered-file->buffer)
2048 (clear-stream _test-output-stream)
2049 (clear-stream $_test-output-buffered-file->buffer)
2050
2051 (write _test-input-stream "fn main -> _/ebx: int {\n")
2052 (write _test-input-stream " var result/eax: int <- do-add 3 4\n")
2053 (write _test-input-stream " return result\n")
2054 (write _test-input-stream "}\n")
2055 (write _test-input-stream "fn do-add a: int, b: int -> _/eax: int {\n")
2056 (write _test-input-stream " var result/eax: int <- copy a\n")
2057 (write _test-input-stream " result <- add b\n")
2058 (write _test-input-stream " return result\n")
2059 (write _test-input-stream "}\n")
2060
2061 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
2062 (flush _test-output-buffered-file)
2063 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
2069
2070 (check-next-stream-line-equal _test-output-stream "main:" "F - test-convert-function-call-with-literal-arg/0")
2071 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-literal-arg/1")
2072 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-literal-arg/2")
2073 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-literal-arg/3")
2074 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-literal-arg/4")
2075 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:loop:" "F - test-convert-function-call-with-literal-arg/5")
2076 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-literal-arg/6")
2077 (check-next-stream-line-equal _test-output-stream " (do-add 3 4)" "F - test-convert-function-call-with-literal-arg/7")
2078 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000003/r32" "F - test-convert-function-call-with-literal-arg/8")
2079 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-local-var-in-reg/9")
2080 (check-next-stream-line-equal _test-output-stream " e9/jump $main:0x00000001:break/disp32" "F - test-convert-function-call-with-literal-arg/10")
2081 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-literal-arg/11")
2082 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:break:" "F - test-convert-function-call-with-literal-arg/12")
2083 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-literal-arg/13")
2084 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-literal-arg/14")
2085 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-literal-arg/15")
2086 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-literal-arg/16")
2087 (check-next-stream-line-equal _test-output-stream "do-add:" "F - test-convert-function-call-with-literal-arg/17")
2088 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-literal-arg/18")
2089 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-literal-arg/19")
2090 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-literal-arg/20")
2091 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-literal-arg/21")
2092 (check-next-stream-line-equal _test-output-stream "$do-add:0x00000002:loop:" "F - test-convert-function-call-with-literal-arg/22")
2093 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-literal-arg/23")
2094 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-function-call-with-literal-arg/24")
2095 (check-next-stream-line-equal _test-output-stream " 03/add *(ebp+0x0000000c) 0x00000000/r32" "F - test-convert-function-call-with-literal-arg/25")
2096 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-function-call-with-literal-arg/26")
2097 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-call-with-literal-arg/27")
2098 (check-next-stream-line-equal _test-output-stream " e9/jump $do-add:0x00000002:break/disp32" "F - test-convert-function-call-with-literal-arg/28")
2099 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-literal-arg/29")
2100 (check-next-stream-line-equal _test-output-stream "$do-add:0x00000002:break:" "F - test-convert-function-call-with-literal-arg/30")
2101 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-literal-arg/31")
2102 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-literal-arg/32")
2103 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-literal-arg/33")
2104 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-literal-arg/34")
2105
2106 89/<- %esp 5/r32/ebp
2107 5d/pop-to-ebp
2108 c3/return
2109
2110 test-convert-function-call-with-literal-string-arg:
2111
2112 55/push-ebp
2113 89/<- %ebp 4/r32/esp
2114
2115 (clear-stream _test-input-stream)
2116 (clear-stream $_test-input-buffered-file->buffer)
2117 (clear-stream _test-output-stream)
2118 (clear-stream $_test-output-buffered-file->buffer)
2119
2120 (write _test-input-stream "fn foo {\n")
2121 (write _test-input-stream " string-func \"abc\"\n")
2122 (write _test-input-stream "}\n")
2123 (write _test-input-stream "sig string-func in: (addr array byte)\n")
2124
2125 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
2126
2127
2128
2129 89/<- %esp 5/r32/ebp
2130 5d/pop-to-ebp
2131 c3/return
2132
2133 test-convert-function-call-with-null-addr:
2134
2135 55/push-ebp
2136 89/<- %ebp 4/r32/esp
2137
2138 (clear-stream _test-input-stream)
2139 (clear-stream $_test-input-buffered-file->buffer)
2140 (clear-stream _test-output-stream)
2141 (clear-stream $_test-output-buffered-file->buffer)
2142
2143 (write _test-input-stream "fn foo {\n")
2144 (write _test-input-stream " bar 0\n")
2145 (write _test-input-stream "}\n")
2146 (write _test-input-stream "sig bar in: (addr int)\n")
2147
2148 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
2149
2150
2151
2152 89/<- %esp 5/r32/ebp
2153 5d/pop-to-ebp
2154 c3/return
2155
2156 test-convert-function-call-with-signature:
2157
2158 55/push-ebp
2159 89/<- %ebp 4/r32/esp
2160
2161 (clear-stream _test-input-stream)
2162 (clear-stream $_test-input-buffered-file->buffer)
2163 (clear-stream _test-output-stream)
2164 (clear-stream $_test-output-buffered-file->buffer)
2165
2166 (write _test-input-stream "fn main -> _/ebx: int {\n")
2167 (write _test-input-stream " var result/eax: int <- do-add 3 4\n")
2168 (write _test-input-stream " return result\n")
2169 (write _test-input-stream "}\n")
2170 (write _test-input-stream "sig do-add a: int, b: int -> _/eax: int\n")
2171
2172 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
2173 (flush _test-output-buffered-file)
2174 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
2180
2181 (check-next-stream-line-equal _test-output-stream "main:" "F - test-convert-function-call-with-signature/0")
2182 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-signature/1")
2183 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-signature/2")
2184 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-signature/3")
2185 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-signature/4")
2186 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:loop:" "F - test-convert-function-call-with-signature/5")
2187 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-literal-arg/6")
2188 (check-next-stream-line-equal _test-output-stream " (do-add 3 4)" "F - test-convert-function-call-with-signature/6")
2189 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000003/r32" "F - test-convert-function-call-with-literal-arg/8")
2190 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-local-var-in-reg/9")
2191 (check-next-stream-line-equal _test-output-stream " e9/jump $main:0x00000001:break/disp32" "F - test-convert-function-call-with-literal-arg/10")
2192 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-signature/7")
2193 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:break:" "F - test-convert-function-call-with-signature/8")
2194 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-signature/9")
2195 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-signature/10")
2196 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-signature/11")
2197 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-signature/12")
2198
2199 89/<- %esp 5/r32/ebp
2200 5d/pop-to-ebp
2201 c3/return
2202
2203 test-convert-function-with-local-var-in-mem:
2204
2205 55/push-ebp
2206 89/<- %ebp 4/r32/esp
2207
2208 (clear-stream _test-input-stream)
2209 (clear-stream $_test-input-buffered-file->buffer)
2210 (clear-stream _test-output-stream)
2211 (clear-stream $_test-output-buffered-file->buffer)
2212
2213 (write _test-input-stream "fn foo {\n")
2214 (write _test-input-stream " var x: int\n")
2215 (write _test-input-stream " increment x\n")
2216 (write _test-input-stream "}\n")
2217
2218 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
2219 (flush _test-output-buffered-file)
2220 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
2226
2227 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-mem/0")
2228 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-mem/1")
2229 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-mem/2")
2230 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-mem/3")
2231 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-mem/4")
2232 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-mem/5")
2233 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-mem/6")
2234 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-mem/7")
2235 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-mem/8")
2236 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-mem/9")
2237 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-mem/10")
2238 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-mem/11")
2239 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-mem/12")
2240 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-mem/13")
2241 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-mem/14")
2242
2243 89/<- %esp 5/r32/ebp
2244 5d/pop-to-ebp
2245 c3/return
2246
2247 test-convert-invalid-literal:
2248
2249 55/push-ebp
2250 89/<- %ebp 4/r32/esp
2251
2252 (clear-stream _test-input-stream)
2253 (clear-stream $_test-input-buffered-file->buffer)
2254 (clear-stream _test-output-stream)
2255 (clear-stream $_test-output-buffered-file->buffer)
2256 (clear-stream _test-error-stream)
2257 (clear-stream $_test-error-buffered-file->buffer)
2258
2259 68/push 0/imm32
2260 68/push 0/imm32
2261 89/<- %edx 4/r32/esp
2262 (tailor-exit-descriptor %edx 0x10)
2263
2264 (write _test-input-stream "fn foo {\n")
2265 (write _test-input-stream " increment 1n\n")
2266 (write _test-input-stream "}\n")
2267
2268 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
2269
2270
2271 89/<- %edx 4/r32/esp
2272 (flush _test-output-buffered-file)
2273 (flush _test-error-buffered-file)
2274 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
2280
2281 (check-stream-equal _test-output-stream "" "F - test-convert-invalid-literal: output should be empty")
2282 (check-next-stream-line-equal _test-error-stream "fn foo: variable '1n' cannot begin with a digit (or do you have a typo in a number?)" "F - test-convert-invalid-literal: error message")
2283
2284 (check-ints-equal *(edx+4) 2 "F - test-convert-invalid-literal: exit status")
2285
2286 81 0/subop/add %esp 8/imm32
2287
2288 5d/pop-to-ebp
2289 c3/return
2290
2291 test-local-var-in-mem-has-no-initializer:
2292
2293 55/push-ebp
2294 89/<- %ebp 4/r32/esp
2295
2296 (clear-stream _test-input-stream)
2297 (clear-stream $_test-input-buffered-file->buffer)
2298 (clear-stream _test-output-stream)
2299 (clear-stream $_test-output-buffered-file->buffer)
2300 (clear-stream _test-error-stream)
2301 (clear-stream $_test-error-buffered-file->buffer)
2302
2303 68/push 0/imm32
2304 68/push 0/imm32
2305 89/<- %edx 4/r32/esp
2306 (tailor-exit-descriptor %edx 0x10)
2307
2308 (write _test-input-stream "fn foo {\n")
2309 (write _test-input-stream " var x: int <- copy 0\n")
2310 (write _test-input-stream " increment x\n")
2311 (write _test-input-stream "}\n")
2312
2313 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
2314
2315
2316 89/<- %edx 4/r32/esp
2317 (flush _test-output-buffered-file)
2318 (flush _test-error-buffered-file)
2319 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
2325
2326 (check-stream-equal _test-output-stream "" "F - test-var-in-mem-has-no-initializer: output should be empty")
2327 (check-next-stream-line-equal _test-error-stream "fn foo: var x: variables on the stack can't take an initializer" "F - test-var-in-mem-has-no-initializer: error message")
2328
2329 (check-ints-equal *(edx+4) 2 "F - test-var-in-mem-has-no-initializer: exit status")
2330
2331 81 0/subop/add %esp 8/imm32
2332
2333 5d/pop-to-ebp
2334 c3/return
2335
2336 test-convert-function-with-local-var-with-compound-type-in-mem:
2337
2338 55/push-ebp
2339 89/<- %ebp 4/r32/esp
2340
2341 (clear-stream _test-input-stream)
2342 (clear-stream $_test-input-buffered-file->buffer)
2343 (clear-stream _test-output-stream)
2344 (clear-stream $_test-output-buffered-file->buffer)
2345
2346 (write _test-input-stream "fn foo {\n")
2347 (write _test-input-stream " var x: (addr int)\n")
2348 (write _test-input-stream " copy-to x, 0\n")
2349 (write _test-input-stream "}\n")
2350
2351 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
2352 (flush _test-output-buffered-file)
2353 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
2359
2360 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-compound-type-in-mem/0")
2361 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-compound-type-in-mem/1")
2362 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-with-compound-type-in-mem/2")
2363 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-with-compound-type-in-mem/3")
2364 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-with-compound-type-in-mem/4")
2365 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-with-compound-type-in-mem/5")
2366 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-compound-type-in-mem/6")
2367 (check-next-stream-line-equal _test-output-stream " c7 0/subop/copy *(ebp+0xfffffffc) 0/imm32" "F - test-convert-function-with-local-var-with-compound-type-in-mem/7")
2368 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-with-compound-type-in-mem/8")
2369 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-with-compound-type-in-mem/9")
2370 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-with-compound-type-in-mem/10")
2371 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-with-compound-type-in-mem/11")
2372 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-with-compound-type-in-mem/12")
2373 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-with-compound-type-in-mem/13")
2374 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-with-compound-type-in-mem/14")
2375
2376 89/<- %esp 5/r32/ebp
2377 5d/pop-to-ebp
2378 c3/return
2379
2380 test-convert-function-with-local-var-in-reg:
2381
2382 55/push-ebp
2383 89/<- %ebp 4/r32/esp
2384
2385 (clear-stream _test-input-stream)
2386 (clear-stream $_test-input-buffered-file->buffer)
2387 (clear-stream _test-output-stream)
2388 (clear-stream $_test-output-buffered-file->buffer)
2389
2390 (write _test-input-stream "fn foo {\n")
2391 (write _test-input-stream " var x/ecx: int <- copy 3\n")
2392 (write _test-input-stream " x <- increment\n")
2393 (write _test-input-stream "}\n")
2394
2395 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
2396 (flush _test-output-buffered-file)
2397 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
2403
2404 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-reg/0")
2405 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-reg/1")
2406 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-reg/2")
2407 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-reg/3")
2408 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-reg/4")
2409 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-reg/5")
2410 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-local-var-in-reg/6")
2411 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-function-with-local-var-in-reg/7")
2412 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-convert-function-with-local-var-in-reg/8")
2413 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-local-var-in-reg/9")
2414 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-reg/10")
2415 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-reg/11")
2416 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-reg/12")
2417 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-reg/13")
2418 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-reg/14")
2419 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-reg/15")
2420
2421 89/<- %esp 5/r32/ebp
2422 5d/pop-to-ebp
2423 c3/return
2424
2425 test-float-var-in-wrong-register:
2426
2427 55/push-ebp
2428 89/<- %ebp 4/r32/esp
2429
2430 (clear-stream _test-input-stream)
2431 (clear-stream $_test-input-buffered-file->buffer)
2432 (clear-stream _test-output-stream)
2433 (clear-stream $_test-output-buffered-file->buffer)
2434 (clear-stream _test-error-stream)
2435 (clear-stream $_test-error-buffered-file->buffer)
2436
2437 68/push 0/imm32
2438 68/push 0/imm32
2439 89/<- %edx 4/r32/esp
2440 (tailor-exit-descriptor %edx 0x10)
2441
2442 (write _test-input-stream "fn foo {\n")
2443 (write _test-input-stream " var x/eax: int <- copy 0\n")
2444 (write _test-input-stream " var y/eax: float <- convert x\n")
2445 (write _test-input-stream "}\n")
2446
2447 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
2448
2449
2450 89/<- %edx 4/r32/esp
2451 (flush _test-output-buffered-file)
2452 (flush _test-error-buffered-file)
2453 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
2459
2460 (check-stream-equal _test-output-stream "" "F - test-float-var-in-wrong-register: output should be empty")
2461 (check-next-stream-line-equal _test-error-stream "fn foo: float var 'y' should be in a floating-point register" "F - test-float-var-in-wrong-register: error message")
2462
2463 (check-ints-equal *(edx+4) 2 "F - test-float-var-in-wrong-register: exit status")
2464
2465 81 0/subop/add %esp 8/imm32
2466
2467 5d/pop-to-ebp
2468 c3/return
2469
2470 test-non-float-var-in-wrong-register:
2471
2472 55/push-ebp
2473 89/<- %ebp 4/r32/esp
2474
2475 (clear-stream _test-input-stream)
2476 (clear-stream $_test-input-buffered-file->buffer)
2477 (clear-stream _test-output-stream)
2478 (clear-stream $_test-output-buffered-file->buffer)
2479 (clear-stream _test-error-stream)
2480 (clear-stream $_test-error-buffered-file->buffer)
2481
2482 68/push 0/imm32
2483 68/push 0/imm32
2484 89/<- %edx 4/r32/esp
2485 (tailor-exit-descriptor %edx 0x10)
2486
2487 (write _test-input-stream "fn foo {\n")
2488 (write _test-input-stream " var x/xmm5: int <- copy 0\n")
2489 (write _test-input-stream "}\n")
2490
2491 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
2492
2493
2494 89/<- %edx 4/r32/esp
2495 (flush _test-output-buffered-file)
2496 (flush _test-error-buffered-file)
2497 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
2503
2504 (check-stream-equal _test-output-stream "" "F - test-non-float-var-in-wrong-register: output should be empty")
2505 (check-next-stream-line-equal _test-error-stream "fn foo: non-float var 'x' should be in an integer register" "F - test-non-float-var-in-wrong-register: error message")
2506
2507 (check-ints-equal *(edx+4) 2 "F - test-non-float-var-in-wrong-register: exit status")
2508
2509 81 0/subop/add %esp 8/imm32
2510
2511 5d/pop-to-ebp
2512 c3/return
2513
2514 test-convert-function-with-allocate:
2515
2516 55/push-ebp
2517 89/<- %ebp 4/r32/esp
2518
2519 (clear-stream _test-input-stream)
2520 (clear-stream $_test-input-buffered-file->buffer)
2521 (clear-stream _test-output-stream)
2522 (clear-stream $_test-output-buffered-file->buffer)
2523
2524 (write _test-input-stream "fn foo {\n")
2525 (write _test-input-stream " var x/ecx: (addr handle int) <- copy 0\n")
2526 (write _test-input-stream " allocate x\n")
2527 (write _test-input-stream "}\n")
2528
2529 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
2530 (flush _test-output-buffered-file)
2531 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
2537
2538 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-allocate/0")
2539 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-allocate/1")
2540 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-allocate/2")
2541 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-allocate/3")
2542 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-allocate/4")
2543 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-allocate/5")
2544 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-allocate/6")
2545 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-allocate/7")
2546 (check-next-stream-line-equal _test-output-stream " (allocate Heap 0x00000004 %ecx)" "F - test-convert-function-with-allocate/8")
2547 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-allocate/9")
2548 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-allocate/10")
2549 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-allocate/11")
2550 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-allocate/12")
2551 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-allocate/13")
2552 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-allocate/14")
2553 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-allocate/15")
2554
2555 89/<- %esp 5/r32/ebp
2556 5d/pop-to-ebp
2557 c3/return
2558
2559 test-initializer-in-hex:
2560
2561 55/push-ebp
2562 89/<- %ebp 4/r32/esp
2563
2564 (clear-stream _test-input-stream)
2565 (clear-stream $_test-input-buffered-file->buffer)
2566 (clear-stream _test-output-stream)
2567 (clear-stream $_test-output-buffered-file->buffer)
2568 (clear-stream _test-error-stream)
2569 (clear-stream $_test-error-buffered-file->buffer)
2570
2571 68/push 0/imm32
2572 68/push 0/imm32
2573 89/<- %edx 4/r32/esp
2574 (tailor-exit-descriptor %edx 0x10)
2575
2576 (write _test-input-stream "fn foo {\n")
2577 (write _test-input-stream " var x/ecx: int <- copy 10\n")
2578 (write _test-input-stream "}\n")
2579
2580 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
2581
2582
2583 89/<- %edx 4/r32/esp
2584 (flush _test-output-buffered-file)
2585 (flush _test-error-buffered-file)
2586 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
2592
2593 (check-stream-equal _test-output-stream "" "F - test-initializer-in-hex: output should be empty")
2594 (check-next-stream-line-equal _test-error-stream "literal integers are always hex in Mu; start '10' with a '0x' to be unambiguous, converting it to hexadecimal as necessary." "F - test-initializer-in-hex: error message")
2595
2596 (check-ints-equal *(edx+4) 2 "F - test-initializer-in-hex: exit status")
2597
2598 81 0/subop/add %esp 8/imm32
2599
2600 5d/pop-to-ebp
2601 c3/return
2602
2603 test-convert-function-with-second-local-var-in-same-reg:
2604
2605 55/push-ebp
2606 89/<- %ebp 4/r32/esp
2607
2608 (clear-stream _test-input-stream)
2609 (clear-stream $_test-input-buffered-file->buffer)
2610 (clear-stream _test-output-stream)
2611 (clear-stream $_test-output-buffered-file->buffer)
2612
2613 (write _test-input-stream "fn foo {\n")
2614 (write _test-input-stream " var x/ecx: int <- copy 3\n")
2615 (write _test-input-stream " var y/ecx: int <- copy 4\n")
2616 (write _test-input-stream " y <- increment\n")
2617 (write _test-input-stream "}\n")
2618
2619 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
2620 (flush _test-output-buffered-file)
2621 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
2627
2628 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-second-local-var-in-same-reg/0")
2629 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-second-local-var-in-same-reg/1")
2630 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-second-local-var-in-same-reg/2")
2631 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-second-local-var-in-same-reg/3")
2632 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-second-local-var-in-same-reg/4")
2633 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-second-local-var-in-same-reg/5")
2634 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-second-local-var-in-same-reg/6")
2635 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-function-with-second-local-var-in-same-reg/7")
2636 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-convert-function-with-second-local-var-in-same-reg/8")
2637 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-convert-function-with-second-local-var-in-same-reg/9")
2638 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-second-local-var-in-same-reg/10")
2639 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-second-local-var-in-same-reg/11")
2640 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-second-local-var-in-same-reg/12")
2641 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-second-local-var-in-same-reg/13")
2642 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-second-local-var-in-same-reg/14")
2643 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-second-local-var-in-same-reg/15")
2644 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-second-local-var-in-same-reg/16")
2645
2646 89/<- %esp 5/r32/ebp
2647 5d/pop-to-ebp
2648 c3/return
2649
2650 test-read-clobbered-reg-var:
2651
2652 55/push-ebp
2653 89/<- %ebp 4/r32/esp
2654
2655 (clear-stream _test-input-stream)
2656 (clear-stream $_test-input-buffered-file->buffer)
2657 (clear-stream _test-output-stream)
2658 (clear-stream $_test-output-buffered-file->buffer)
2659 (clear-stream _test-error-stream)
2660 (clear-stream $_test-error-buffered-file->buffer)
2661
2662 68/push 0/imm32
2663 68/push 0/imm32
2664 89/<- %edx 4/r32/esp
2665 (tailor-exit-descriptor %edx 0x10)
2666
2667 (write _test-input-stream "fn foo {\n")
2668 (write _test-input-stream " var x/ecx: int <- copy 3\n")
2669 (write _test-input-stream " var y/ecx: int <- copy 4\n")
2670 (write _test-input-stream " x <- increment\n")
2671 (write _test-input-stream "}\n")
2672
2673 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
2674
2675
2676 89/<- %edx 4/r32/esp
2677 (flush _test-output-buffered-file)
2678 (flush _test-error-buffered-file)
2679 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
2685
2686 (check-stream-equal _test-output-stream "" "F - test-read-clobbered-reg-var: output should be empty")
2687 (check-next-stream-line-equal _test-error-stream "fn foo: register ecx reads var 'x' after writing var 'y'" "F - test-read-clobbered-reg-var: error message")
2688
2689 (check-ints-equal *(edx+4) 2 "F - test-read-clobbered-reg-var: exit status")
2690
2691 81 0/subop/add %esp 8/imm32
2692
2693 5d/pop-to-ebp
2694 c3/return
2695
2696 test-overlapping-int-fp-registers:
2697
2698 55/push-ebp
2699 89/<- %ebp 4/r32/esp
2700
2701 (clear-stream _test-input-stream)
2702 (clear-stream $_test-input-buffered-file->buffer)
2703 (clear-stream _test-output-stream)
2704 (clear-stream $_test-output-buffered-file->buffer)
2705 (clear-stream _test-error-stream)
2706 (clear-stream $_test-error-buffered-file->buffer)
2707
2708 68/push 0/imm32
2709 68/push 0/imm32
2710 89/<- %edx 4/r32/esp
2711 (tailor-exit-descriptor %edx 0x10)
2712
2713 (write _test-input-stream "fn foo {\n")
2714 (write _test-input-stream " var x/eax: int <- copy 3\n")
2715 (write _test-input-stream " var y/xmm0: float <- convert x\n")
2716 (write _test-input-stream " x <- increment\n")
2717 (write _test-input-stream "}\n")
2718
2719 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
2720
2721
2722 89/<- %edx 4/r32/esp
2723 (flush _test-output-buffered-file)
2724 (flush _test-error-buffered-file)
2725 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
2731
2732 (check-next-stream-line-equal _test-error-stream "" "F - test-overlapping-int-fp-registers: error message")
2733
2734
2735 81 0/subop/add %esp 8/imm32
2736
2737 5d/pop-to-ebp
2738 c3/return
2739
2740 test-convert-function-call:
2741
2742 55/push-ebp
2743 89/<- %ebp 4/r32/esp
2744
2745 (clear-stream _test-input-stream)
2746 (clear-stream $_test-input-buffered-file->buffer)
2747 (clear-stream _test-output-stream)
2748 (clear-stream $_test-output-buffered-file->buffer)
2749
2750 (write _test-input-stream "fn main -> _/ebx: int {\n")
2751 (write _test-input-stream " var result/ebx: int <- foo\n")
2752 (write _test-input-stream " return result\n")
2753 (write _test-input-stream "}\n")
2754 (write _test-input-stream "fn foo -> _/ebx: int {\n")
2755 (write _test-input-stream " var result/ebx: int <- copy 3\n")
2756 (write _test-input-stream " return result\n")
2757 (write _test-input-stream "}\n")
2758
2759 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
2760 (flush _test-output-buffered-file)
2761 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
2767
2768 (check-next-stream-line-equal _test-output-stream "main:" "F - test-convert-function-call/0")
2769 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call/1")
2770 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call/2")
2771 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call/3")
2772 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call/4")
2773 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:loop:" "F - test-convert-function-call/5")
2774 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ebx" "F - test-convert-function-call-with-literal-arg/6")
2775 (check-next-stream-line-equal _test-output-stream " (foo)" "F - test-convert-function-call/6")
2776 (check-next-stream-line-equal _test-output-stream " 8b/-> %ebx 0x00000003/r32" "F - test-convert-function-call-with-literal-arg/8")
2777 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-call-with-literal-arg/27")
2778 (check-next-stream-line-equal _test-output-stream " e9/jump $main:0x00000001:break/disp32" "F - test-convert-function-call-with-literal-arg/10")
2779 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call/7")
2780 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:break:" "F - test-convert-function-call/8")
2781 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call/9")
2782 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call/10")
2783 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call/11")
2784 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call/12")
2785 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call/13")
2786 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call/14")
2787 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call/15")
2788 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call/16")
2789 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call/17")
2790 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-call/18")
2791 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ebx" "F - test-convert-function-call-with-literal-arg/6")
2792 (check-next-stream-line-equal _test-output-stream " bb/copy-to-ebx 3/imm32" "F - test-convert-function-call/19")
2793 (check-next-stream-line-equal _test-output-stream " 8b/-> %ebx 0x00000003/r32" "F - test-convert-function-call-with-literal-arg/8")
2794 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-call-with-literal-arg/27")
2795 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-call-with-literal-arg/10")
2796 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call/20")
2797 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-call/21")
2798 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call/22")
2799 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call/23")
2800 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call/24")
2801 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call/25")
2802
2803 89/<- %esp 5/r32/ebp
2804 5d/pop-to-ebp
2805 c3/return
2806
2807 test-convert-function-call-with-inout-with-compound-type:
2808
2809 55/push-ebp
2810 89/<- %ebp 4/r32/esp
2811
2812 (clear-stream _test-input-stream)
2813 (clear-stream $_test-input-buffered-file->buffer)
2814 (clear-stream _test-output-stream)
2815 (clear-stream $_test-output-buffered-file->buffer)
2816
2817 (write _test-input-stream "fn f {\n")
2818 (write _test-input-stream " var x: (addr int)\n")
2819 (write _test-input-stream " g x\n")
2820 (write _test-input-stream "}\n")
2821 (write _test-input-stream "fn g a: (addr int) {\n")
2822 (write _test-input-stream "}\n")
2823
2824 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
2825 (flush _test-output-buffered-file)
2826 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
2832
2833 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-inout-with-compound-type/0")
2834 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-inout-with-compound-type/1")
2835 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-inout-with-compound-type/2")
2836 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-inout-with-compound-type/3")
2837 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-inout-with-compound-type/4")
2838 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-inout-with-compound-type/5")
2839 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-inout-with-compound-type/6")
2840 (check-next-stream-line-equal _test-output-stream " (g *(ebp+0xfffffffc))" "F - test-convert-function-call-with-inout-with-compound-type/7")
2841 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-call-with-inout-with-compound-type/8")
2842 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-inout-with-compound-type/9")
2843 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-inout-with-compound-type/10")
2844 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-inout-with-compound-type/11")
2845 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-inout-with-compound-type/12")
2846 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-inout-with-compound-type/13")
2847 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-inout-with-compound-type/14")
2848 (check-next-stream-line-equal _test-output-stream "g:" "F - test-convert-function-call-with-inout-with-compound-type/15")
2849 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-inout-with-compound-type/16")
2850 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-inout-with-compound-type/17")
2851 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-inout-with-compound-type/18")
2852 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-inout-with-compound-type/19")
2853 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-inout-with-compound-type/20")
2854 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-inout-with-compound-type/21")
2855 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-inout-with-compound-type/22")
2856
2857 89/<- %esp 5/r32/ebp
2858 5d/pop-to-ebp
2859 c3/return
2860
2861 test-convert-function-call-with-inout-with-type-parameter:
2862
2863 55/push-ebp
2864 89/<- %ebp 4/r32/esp
2865
2866 (clear-stream _test-input-stream)
2867 (clear-stream $_test-input-buffered-file->buffer)
2868 (clear-stream _test-output-stream)
2869 (clear-stream $_test-output-buffered-file->buffer)
2870 (clear-stream _test-error-stream)
2871 (clear-stream $_test-error-buffered-file->buffer)
2872
2873 68/push 0/imm32
2874 68/push 0/imm32
2875 89/<- %edx 4/r32/esp
2876 (tailor-exit-descriptor %edx 0x10)
2877
2878 (write _test-input-stream "fn f {\n")
2879 (write _test-input-stream " var x: (addr int)\n")
2880 (write _test-input-stream " g x\n")
2881 (write _test-input-stream "}\n")
2882 (write _test-input-stream "fn g a: (addr _) {\n")
2883 (write _test-input-stream "}\n")
2884
2885 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
2886
2887
2888 89/<- %edx 4/r32/esp
2889 (flush _test-output-buffered-file)
2890 (flush _test-error-buffered-file)
2891 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
2897
2898 (check-stream-equal _test-error-stream "" "F - test-convert-function-call-with-inout-with-type-parameter: error stream should be empty")
2899
2900
2901 81 0/subop/add %esp 8/imm32
2902
2903 5d/pop-to-ebp
2904 c3/return
2905
2906 test-convert-function-call-with-incorrect-inout-type:
2907
2908 55/push-ebp
2909 89/<- %ebp 4/r32/esp
2910
2911 (clear-stream _test-input-stream)
2912 (clear-stream $_test-input-buffered-file->buffer)
2913 (clear-stream _test-output-stream)
2914 (clear-stream $_test-output-buffered-file->buffer)
2915 (clear-stream _test-error-stream)
2916 (clear-stream $_test-error-buffered-file->buffer)
2917
2918 68/push 0/imm32
2919 68/push 0/imm32
2920 89/<- %edx 4/r32/esp
2921 (tailor-exit-descriptor %edx 0x10)
2922
2923 (write _test-input-stream "fn f {\n")
2924 (write _test-input-stream " var x: int\n")
2925 (write _test-input-stream " g x\n")
2926 (write _test-input-stream "}\n")
2927 (write _test-input-stream "fn g a: foo {\n")
2928 (write _test-input-stream "}\n")
2929
2930 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
2931
2932
2933 89/<- %edx 4/r32/esp
2934 (flush _test-output-buffered-file)
2935 (flush _test-error-buffered-file)
2936 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
2942
2943 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-inout-type: output should be empty")
2944 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for inout 'x' is not right" "F - test-convert-function-call-with-incorrect-inout-type: error message")
2945
2946 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-incorrect-inout-type: exit status")
2947
2948 81 0/subop/add %esp 8/imm32
2949 5d/pop-to-ebp
2950 c3/return
2951
2952 test-convert-function-call-with-inout-with-incorrect-compound-type:
2953
2954 55/push-ebp
2955 89/<- %ebp 4/r32/esp
2956
2957 (clear-stream _test-input-stream)
2958 (clear-stream $_test-input-buffered-file->buffer)
2959 (clear-stream _test-output-stream)
2960 (clear-stream $_test-output-buffered-file->buffer)
2961 (clear-stream _test-error-stream)
2962 (clear-stream $_test-error-buffered-file->buffer)
2963
2964 68/push 0/imm32
2965 68/push 0/imm32
2966 89/<- %edx 4/r32/esp
2967 (tailor-exit-descriptor %edx 0x10)
2968
2969 (write _test-input-stream "fn f {\n")
2970 (write _test-input-stream " var x: (addr int)\n")
2971 (write _test-input-stream " g x\n")
2972 (write _test-input-stream "}\n")
2973 (write _test-input-stream "fn g a: (addr bool) {\n")
2974 (write _test-input-stream "}\n")
2975
2976 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
2977
2978
2979 89/<- %edx 4/r32/esp
2980 (flush _test-output-buffered-file)
2981 (flush _test-error-buffered-file)
2982 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
2988
2989 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-inout-with-incorrect-compound-type: output should be empty")
2990 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for inout 'x' is not right" "F - test-convert-function-call-with-inout-with-incorrect-compound-type: error message")
2991
2992 81 0/subop/add %esp 8/imm32
2993
2994 5d/pop-to-ebp
2995 c3/return
2996
2997 test-convert-function-call-with-inout-with-multiple-type-parameters:
2998
2999 55/push-ebp
3000 89/<- %ebp 4/r32/esp
3001
3002 (clear-stream _test-input-stream)
3003 (clear-stream $_test-input-buffered-file->buffer)
3004 (clear-stream _test-output-stream)
3005 (clear-stream $_test-output-buffered-file->buffer)
3006 (clear-stream _test-error-stream)
3007 (clear-stream $_test-error-buffered-file->buffer)
3008
3009 68/push 0/imm32
3010 68/push 0/imm32
3011 89/<- %edx 4/r32/esp
3012 (tailor-exit-descriptor %edx 0x10)
3013
3014 (write _test-input-stream "fn f {\n")
3015 (write _test-input-stream " var x: (addr int)\n")
3016 (write _test-input-stream " var y: (addr int)\n")
3017 (write _test-input-stream " g x, y\n")
3018 (write _test-input-stream "}\n")
3019 (write _test-input-stream "fn g a: (addr _), b: (addr _) {\n")
3020 (write _test-input-stream "}\n")
3021
3022 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
3023
3024
3025 89/<- %edx 4/r32/esp
3026 (flush _test-output-buffered-file)
3027 (flush _test-error-buffered-file)
3028 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
3034
3035 (check-stream-equal _test-error-stream "" "F - test-convert-function-call-with-inout-with-multiple-type-parameters: error stream should be empty")
3036
3037
3038 81 0/subop/add %esp 8/imm32
3039
3040 5d/pop-to-ebp
3041 c3/return
3042
3043 test-type-parameter-matches-rest-of-type:
3044
3045 55/push-ebp
3046 89/<- %ebp 4/r32/esp
3047
3048 (clear-stream _test-input-stream)
3049 (clear-stream $_test-input-buffered-file->buffer)
3050 (clear-stream _test-output-stream)
3051 (clear-stream $_test-output-buffered-file->buffer)
3052 (clear-stream _test-error-stream)
3053 (clear-stream $_test-error-buffered-file->buffer)
3054
3055 68/push 0/imm32
3056 68/push 0/imm32
3057 89/<- %edx 4/r32/esp
3058 (tailor-exit-descriptor %edx 0x10)
3059
3060 (write _test-input-stream "fn f {\n")
3061 (write _test-input-stream " var x: (addr array int)\n")
3062 (write _test-input-stream " g x\n")
3063 (write _test-input-stream "}\n")
3064 (write _test-input-stream "fn g a: (addr _) {\n")
3065 (write _test-input-stream "}\n")
3066
3067 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
3068
3069
3070 89/<- %edx 4/r32/esp
3071 (flush _test-output-buffered-file)
3072 (flush _test-error-buffered-file)
3073 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
3079
3080 (check-stream-equal _test-error-stream "" "F - test-type-parameter-matches-rest-of-type: error stream should be empty")
3081
3082
3083 81 0/subop/add %esp 8/imm32
3084
3085 5d/pop-to-ebp
3086 c3/return
3087
3088 test-convert-function-call-with-inout-with-incompatible-type-parameters:
3089
3090 55/push-ebp
3091 89/<- %ebp 4/r32/esp
3092
3093 (clear-stream _test-input-stream)
3094 (clear-stream $_test-input-buffered-file->buffer)
3095 (clear-stream _test-output-stream)
3096 (clear-stream $_test-output-buffered-file->buffer)
3097 (clear-stream _test-error-stream)
3098 (clear-stream $_test-error-buffered-file->buffer)
3099
3100 68/push 0/imm32
3101 68/push 0/imm32
3102 89/<- %edx 4/r32/esp
3103 (tailor-exit-descriptor %edx 0x10)
3104
3105 (write _test-input-stream "fn f {\n")
3106 (write _test-input-stream " var x: (addr int)\n")
3107 (write _test-input-stream " var y: (addr boolean)\n")
3108 (write _test-input-stream " g x, y\n")
3109 (write _test-input-stream "}\n")
3110 (write _test-input-stream "fn g a: (addr _T), b: (addr _T) {\n")
3111 (write _test-input-stream "}\n")
3112
3113 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
3114
3115
3116 89/<- %edx 4/r32/esp
3117 (flush _test-output-buffered-file)
3118 (flush _test-error-buffered-file)
3119 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
3125
3126 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-inout-with-incompatible-type-parameters: output should be empty")
3127 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for inout 'y' is not right" "F - test-convert-function-call-with-inout-with-incompatible-type-parameters: error message")
3128
3129 81 0/subop/add %esp 8/imm32
3130
3131 5d/pop-to-ebp
3132 c3/return
3133
3134 test-convert-function-call-with-too-few-inouts:
3135
3136 55/push-ebp
3137 89/<- %ebp 4/r32/esp
3138
3139 (clear-stream _test-input-stream)
3140 (clear-stream $_test-input-buffered-file->buffer)
3141 (clear-stream _test-output-stream)
3142 (clear-stream $_test-output-buffered-file->buffer)
3143 (clear-stream _test-error-stream)
3144 (clear-stream $_test-error-buffered-file->buffer)
3145
3146 68/push 0/imm32
3147 68/push 0/imm32
3148 89/<- %edx 4/r32/esp
3149 (tailor-exit-descriptor %edx 0x10)
3150
3151 (write _test-input-stream "fn f {\n")
3152 (write _test-input-stream " g\n")
3153 (write _test-input-stream "}\n")
3154 (write _test-input-stream "fn g a: int {\n")
3155 (write _test-input-stream "}\n")
3156
3157 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
3158
3159
3160 89/<- %edx 4/r32/esp
3161 (flush _test-output-buffered-file)
3162 (flush _test-error-buffered-file)
3163 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
3169
3170 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-few-inouts: output should be empty")
3171 (check-next-stream-line-equal _test-error-stream "fn f: call g: too few inouts" "F - test-convert-function-call-with-too-few-inouts: error message")
3172
3173 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-few-inouts: exit status")
3174
3175 81 0/subop/add %esp 8/imm32
3176 5d/pop-to-ebp
3177 c3/return
3178
3179 test-convert-function-call-with-too-many-inouts:
3180
3181 55/push-ebp
3182 89/<- %ebp 4/r32/esp
3183
3184 (clear-stream _test-input-stream)
3185 (clear-stream $_test-input-buffered-file->buffer)
3186 (clear-stream _test-output-stream)
3187 (clear-stream $_test-output-buffered-file->buffer)
3188 (clear-stream _test-error-stream)
3189 (clear-stream $_test-error-buffered-file->buffer)
3190
3191 68/push 0/imm32
3192 68/push 0/imm32
3193 89/<- %edx 4/r32/esp
3194 (tailor-exit-descriptor %edx 0x10)
3195
3196 (write _test-input-stream "fn f {\n")
3197 (write _test-input-stream " var x: int\n")
3198 (write _test-input-stream " g x\n")
3199 (write _test-input-stream "}\n")
3200 (write _test-input-stream "fn g {\n")
3201 (write _test-input-stream "}\n")
3202
3203 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
3204
3205
3206 89/<- %edx 4/r32/esp
3207 (flush _test-output-buffered-file)
3208 (flush _test-error-buffered-file)
3209 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
3215
3216 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-many-inouts: output should be empty")
3217 (check-next-stream-line-equal _test-error-stream "fn f: call g: too many inouts" "F - test-convert-function-call-with-too-many-inouts: error message")
3218
3219 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-many-inouts: exit status")
3220
3221 81 0/subop/add %esp 8/imm32
3222 5d/pop-to-ebp
3223 c3/return
3224
3225 test-convert-function-call-with-incorrect-output-type:
3226
3227 55/push-ebp
3228 89/<- %ebp 4/r32/esp
3229
3230 (clear-stream _test-input-stream)
3231 (clear-stream $_test-input-buffered-file->buffer)
3232 (clear-stream _test-output-stream)
3233 (clear-stream $_test-output-buffered-file->buffer)
3234 (clear-stream _test-error-stream)
3235 (clear-stream $_test-error-buffered-file->buffer)
3236
3237 68/push 0/imm32
3238 68/push 0/imm32
3239 89/<- %edx 4/r32/esp
3240 (tailor-exit-descriptor %edx 0x10)
3241
3242 (write _test-input-stream "fn f {\n")
3243 (write _test-input-stream " var x/eax: int <- g\n")
3244 (write _test-input-stream "}\n")
3245 (write _test-input-stream "fn g -> _/eax: foo {\n")
3246 (write _test-input-stream "}\n")
3247
3248 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
3249
3250
3251 89/<- %edx 4/r32/esp
3252 (flush _test-output-buffered-file)
3253 (flush _test-error-buffered-file)
3254 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
3260
3261 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-output-type: output should be empty")
3262 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for output 'x' is not right" "F - test-convert-function-call-with-incorrect-output-type: error message")
3263
3264 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-incorrect-output-type: exit status")
3265
3266 81 0/subop/add %esp 8/imm32
3267 5d/pop-to-ebp
3268 c3/return
3269
3270 test-convert-function-call-with-too-few-outputs:
3271
3272 55/push-ebp
3273 89/<- %ebp 4/r32/esp
3274
3275 (clear-stream _test-input-stream)
3276 (clear-stream $_test-input-buffered-file->buffer)
3277 (clear-stream _test-output-stream)
3278 (clear-stream $_test-output-buffered-file->buffer)
3279 (clear-stream _test-error-stream)
3280 (clear-stream $_test-error-buffered-file->buffer)
3281
3282 68/push 0/imm32
3283 68/push 0/imm32
3284 89/<- %edx 4/r32/esp
3285 (tailor-exit-descriptor %edx 0x10)
3286
3287 (write _test-input-stream "fn f {\n")
3288 (write _test-input-stream " g\n")
3289 (write _test-input-stream "}\n")
3290 (write _test-input-stream "fn g -> _/eax: int {\n")
3291 (write _test-input-stream "}\n")
3292
3293 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
3294
3295
3296 89/<- %edx 4/r32/esp
3297 (flush _test-output-buffered-file)
3298 (flush _test-error-buffered-file)
3299 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
3305
3306 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-few-outputs: output should be empty")
3307 (check-next-stream-line-equal _test-error-stream "fn f: call g: too few outputs" "F - test-convert-function-call-with-too-few-outputs: error message")
3308
3309 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-few-outputs: exit status")
3310
3311 81 0/subop/add %esp 8/imm32
3312 5d/pop-to-ebp
3313 c3/return
3314
3315 test-convert-function-call-with-too-many-outputs:
3316
3317 55/push-ebp
3318 89/<- %ebp 4/r32/esp
3319
3320 (clear-stream _test-input-stream)
3321 (clear-stream $_test-input-buffered-file->buffer)
3322 (clear-stream _test-output-stream)
3323 (clear-stream $_test-output-buffered-file->buffer)
3324 (clear-stream _test-error-stream)
3325 (clear-stream $_test-error-buffered-file->buffer)
3326
3327 68/push 0/imm32
3328 68/push 0/imm32
3329 89/<- %edx 4/r32/esp
3330 (tailor-exit-descriptor %edx 0x10)
3331
3332 (write _test-input-stream "fn f {\n")
3333 (write _test-input-stream " var x/eax: int <- g\n")
3334 (write _test-input-stream "}\n")
3335 (write _test-input-stream "fn g {\n")
3336 (write _test-input-stream "}\n")
3337
3338 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
3339
3340
3341 89/<- %edx 4/r32/esp
3342 (flush _test-output-buffered-file)
3343 (flush _test-error-buffered-file)
3344 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
3350
3351 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-many-outputs: output should be empty")
3352 (check-next-stream-line-equal _test-error-stream "fn f: call g: too many outputs" "F - test-convert-function-call-with-too-many-outputs: error message")
3353
3354 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-many-outputs: exit status")
3355
3356 81 0/subop/add %esp 8/imm32
3357 5d/pop-to-ebp
3358 c3/return
3359
3360 test-convert-function-call-with-missing-output-register:
3361
3362 55/push-ebp
3363 89/<- %ebp 4/r32/esp
3364
3365 (clear-stream _test-input-stream)
3366 (clear-stream $_test-input-buffered-file->buffer)
3367 (clear-stream _test-output-stream)
3368 (clear-stream $_test-output-buffered-file->buffer)
3369 (clear-stream _test-error-stream)
3370 (clear-stream $_test-error-buffered-file->buffer)
3371
3372 68/push 0/imm32
3373 68/push 0/imm32
3374 89/<- %edx 4/r32/esp
3375 (tailor-exit-descriptor %edx 0x10)
3376
3377 (write _test-input-stream "fn f {\n")
3378 (write _test-input-stream " var x: int\n")
3379 (write _test-input-stream " x <- g\n")
3380 (write _test-input-stream "}\n")
3381 (write _test-input-stream "fn g -> _/eax: int {\n")
3382 (write _test-input-stream "}\n")
3383
3384 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
3385
3386
3387 89/<- %edx 4/r32/esp
3388 (flush _test-output-buffered-file)
3389 (flush _test-error-buffered-file)
3390 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
3396
3397 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-missing-output-register: output should be empty")
3398 (check-next-stream-line-equal _test-error-stream "fn f: call g: output 'x' is not in a register" "F - test-convert-function-call-with-missing-output-register: error message")
3399
3400 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-missing-output-register: exit status")
3401
3402 81 0/subop/add %esp 8/imm32
3403 5d/pop-to-ebp
3404 c3/return
3405
3406 test-convert-function-call-with-incorrect-output-register:
3407
3408 55/push-ebp
3409 89/<- %ebp 4/r32/esp
3410
3411 (clear-stream _test-input-stream)
3412 (clear-stream $_test-input-buffered-file->buffer)
3413 (clear-stream _test-output-stream)
3414 (clear-stream $_test-output-buffered-file->buffer)
3415 (clear-stream _test-error-stream)
3416 (clear-stream $_test-error-buffered-file->buffer)
3417
3418 68/push 0/imm32
3419 68/push 0/imm32
3420 89/<- %edx 4/r32/esp
3421 (tailor-exit-descriptor %edx 0x10)
3422
3423 (write _test-input-stream "fn f {\n")
3424 (write _test-input-stream " var x/ecx: int <- g\n")
3425 (write _test-input-stream "}\n")
3426 (write _test-input-stream "fn g -> _/eax: int {\n")
3427 (write _test-input-stream "}\n")
3428
3429 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
3430
3431
3432 89/<- %edx 4/r32/esp
3433 (flush _test-output-buffered-file)
3434 (flush _test-error-buffered-file)
3435 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
3441
3442 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-output-register: output should be empty")
3443 (check-next-stream-line-equal _test-error-stream "fn f: call g: register for output 'x' is not right" "F - test-convert-function-call-with-incorrect-output-register: error message")
3444
3445 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-incorrect-output-register: exit status")
3446
3447 81 0/subop/add %esp 8/imm32
3448 5d/pop-to-ebp
3449 c3/return
3450
3451 test-convert-function-with-local-var-dereferenced:
3452
3453 55/push-ebp
3454 89/<- %ebp 4/r32/esp
3455
3456 (clear-stream _test-input-stream)
3457 (clear-stream $_test-input-buffered-file->buffer)
3458 (clear-stream _test-output-stream)
3459 (clear-stream $_test-output-buffered-file->buffer)
3460
3461 (write _test-input-stream "fn foo {\n")
3462 (write _test-input-stream " var x/ecx: (addr int) <- copy 0\n")
3463 (write _test-input-stream " increment *x\n")
3464 (write _test-input-stream "}\n")
3465
3466 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
3467 (flush _test-output-buffered-file)
3468 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
3474
3475 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-dereferenced/0")
3476 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-dereferenced/1")
3477 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-dereferenced/2")
3478 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-dereferenced/3")
3479 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-dereferenced/4")
3480 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-dereferenced/5")
3481 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-local-var-dereferenced/6")
3482 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-local-var-dereferenced/7")
3483 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *ecx" "F - test-convert-function-with-local-var-dereferenced/8")
3484 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-local-var-dereferenced/9")
3485 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-dereferenced/10")
3486 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-dereferenced/11")
3487 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-dereferenced/12")
3488 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-dereferenced/13")
3489 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-dereferenced/14")
3490 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-dereferenced/15")
3491
3492 89/<- %esp 5/r32/ebp
3493 5d/pop-to-ebp
3494 c3/return
3495
3496 test-dereference-of-var-on-stack:
3497
3498 55/push-ebp
3499 89/<- %ebp 4/r32/esp
3500
3501 (clear-stream _test-input-stream)
3502 (clear-stream $_test-input-buffered-file->buffer)
3503 (clear-stream _test-output-stream)
3504 (clear-stream $_test-output-buffered-file->buffer)
3505 (clear-stream _test-error-stream)
3506 (clear-stream $_test-error-buffered-file->buffer)
3507
3508 68/push 0/imm32
3509 68/push 0/imm32
3510 89/<- %edx 4/r32/esp
3511 (tailor-exit-descriptor %edx 0x10)
3512
3513 (write _test-input-stream "fn foo {\n")
3514 (write _test-input-stream " var x: (addr int)\n")
3515 (write _test-input-stream " increment *x\n")
3516 (write _test-input-stream "}\n")
3517
3518 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
3519
3520
3521 89/<- %edx 4/r32/esp
3522 (flush _test-output-buffered-file)
3523 (flush _test-error-buffered-file)
3524 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
3530
3531 (check-stream-equal _test-output-stream "" "F - test-dereference-of-var-on-stack: output should be empty")
3532 (check-next-stream-line-equal _test-error-stream "fn foo: cannot dereference var 'x' on stack" "F - test-dereference-of-var-on-stack: error message")
3533
3534 (check-ints-equal *(edx+4) 2 "F - test-dereference-of-var-on-stack: exit status")
3535
3536 81 0/subop/add %esp 8/imm32
3537
3538 5d/pop-to-ebp
3539 c3/return
3540
3541 test-convert-function-with-byte-operations:
3542
3543 55/push-ebp
3544 89/<- %ebp 4/r32/esp
3545
3546 (clear-stream _test-input-stream)
3547 (clear-stream $_test-input-buffered-file->buffer)
3548 (clear-stream _test-output-stream)
3549 (clear-stream $_test-output-buffered-file->buffer)
3550
3551 (write _test-input-stream "fn foo {\n")
3552 (write _test-input-stream " var x/eax: byte <- copy 0\n")
3553 (write _test-input-stream " var y/ecx: byte <- copy 0\n")
3554 (write _test-input-stream " y <- copy-byte x\n")
3555 (write _test-input-stream " var z/edx: (addr byte) <- copy 0\n")
3556 (write _test-input-stream " y <- copy-byte *z\n")
3557 (write _test-input-stream " copy-byte-to *z, x\n")
3558 (write _test-input-stream "}\n")
3559
3560 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
3561 (flush _test-output-buffered-file)
3562 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
3568
3569 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-byte-operations/0")
3570 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-byte-operations/1")
3571 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-byte-operations/2")
3572 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-byte-operations/3")
3573 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-byte-operations/4")
3574 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-byte-operations/5")
3575 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-byte-operations/6")
3576 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-with-byte-operations/7")
3577 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-byte-operations/8")
3578 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-byte-operations/9")
3579 (check-next-stream-line-equal _test-output-stream " 8a/byte-> %eax 0x00000001/r32" "F - test-convert-function-with-byte-operations/10")
3580 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-convert-function-with-byte-operations/11")
3581 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 0/imm32" "F - test-convert-function-with-byte-operations/12")
3582 (check-next-stream-line-equal _test-output-stream " 8a/byte-> *edx 0x00000001/r32" "F - test-convert-function-with-byte-operations/13")
3583 (check-next-stream-line-equal _test-output-stream " 88/byte<- *edx 0x00000000/r32" "F - test-convert-function-with-byte-operations/14")
3584 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-convert-function-with-byte-operations/15")
3585 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-byte-operations/16")
3586 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-byte-operations/17")
3587 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-byte-operations/18")
3588 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-byte-operations/19")
3589 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-byte-operations/20")
3590 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-byte-operations/21")
3591 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-byte-operations/22")
3592 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-byte-operations/23")
3593
3594 89/<- %esp 5/r32/ebp
3595 5d/pop-to-ebp
3596 c3/return
3597
3598
3599 test-byte-values-on-stack:
3600
3601 55/push-ebp
3602 89/<- %ebp 4/r32/esp
3603
3604 (clear-stream _test-input-stream)
3605 (clear-stream $_test-input-buffered-file->buffer)
3606 (clear-stream _test-output-stream)
3607 (clear-stream $_test-output-buffered-file->buffer)
3608 (clear-stream _test-error-stream)
3609 (clear-stream $_test-error-buffered-file->buffer)
3610
3611 68/push 0/imm32
3612 68/push 0/imm32
3613 89/<- %edx 4/r32/esp
3614 (tailor-exit-descriptor %edx 0x10)
3615
3616 (write _test-input-stream "fn foo {\n")
3617 (write _test-input-stream " var x: byte\n")
3618 (write _test-input-stream "}\n")
3619
3620 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
3621
3622
3623 89/<- %edx 4/r32/esp
3624 (flush _test-output-buffered-file)
3625 (flush _test-error-buffered-file)
3626 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
3632
3633 (check-stream-equal _test-output-stream "" "F - test-byte-values-on-stack: output should be empty")
3634 (check-next-stream-line-equal _test-error-stream "fn foo: var 'x' of type 'byte' cannot be on the stack" "F - test-byte-values-on-stack: error message")
3635
3636 (check-ints-equal *(edx+4) 2 "F - test-byte-values-on-stack: exit status")
3637
3638 81 0/subop/add %esp 8/imm32
3639
3640 5d/pop-to-ebp
3641 c3/return
3642
3643
3644 test-byte-values-in-unsupported-registers:
3645
3646 55/push-ebp
3647 89/<- %ebp 4/r32/esp
3648
3649 (clear-stream _test-input-stream)
3650 (clear-stream $_test-input-buffered-file->buffer)
3651 (clear-stream _test-output-stream)
3652 (clear-stream $_test-output-buffered-file->buffer)
3653 (clear-stream _test-error-stream)
3654 (clear-stream $_test-error-buffered-file->buffer)
3655
3656 68/push 0/imm32
3657 68/push 0/imm32
3658 89/<- %edx 4/r32/esp
3659 (tailor-exit-descriptor %edx 0x10)
3660
3661 (write _test-input-stream "fn foo {\n")
3662 (write _test-input-stream " var x/esi: byte <- copy 0\n")
3663 (write _test-input-stream "}\n")
3664
3665 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
3666
3667
3668 89/<- %edx 4/r32/esp
3669 (flush _test-output-buffered-file)
3670 (flush _test-error-buffered-file)
3671 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
3677
3678 (check-stream-equal _test-output-stream "" "F - test-byte-values-in-unsupported-registers: output should be empty")
3679 (check-next-stream-line-equal _test-error-stream "fn foo: var 'x' of type 'byte' cannot be in esi or edi" "F - test-byte-values-in-unsupported-registers: error message")
3680
3681 (check-ints-equal *(edx+4) 2 "F - test-byte-values-in-unsupported-registers: exit status")
3682
3683 81 0/subop/add %esp 8/imm32
3684
3685 5d/pop-to-ebp
3686 c3/return
3687
3688
3689 test-copy-byte-var-from-fn-arg:
3690
3691 55/push-ebp
3692 89/<- %ebp 4/r32/esp
3693
3694 (clear-stream _test-input-stream)
3695 (clear-stream $_test-input-buffered-file->buffer)
3696 (clear-stream _test-output-stream)
3697 (clear-stream $_test-output-buffered-file->buffer)
3698
3699 (write _test-input-stream "fn foo x: byte, y: int {\n")
3700 (write _test-input-stream " var a/eax: byte <- copy x\n")
3701 (write _test-input-stream " var b/eax: int <- copy y\n")
3702 (write _test-input-stream "}\n")
3703
3704 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
3705 (flush _test-output-buffered-file)
3706 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
3712
3713 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-copy-byte-from-fn-arg/0")
3714 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-copy-byte-from-fn-arg/1")
3715 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-copy-byte-from-fn-arg/2")
3716 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-copy-byte-from-fn-arg/3")
3717 (check-next-stream-line-equal _test-output-stream " {" "F - test-copy-byte-from-fn-arg/4")
3718 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-copy-byte-from-fn-arg/5")
3719 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-copy-byte-from-fn-arg/6")
3720 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-copy-byte-from-fn-arg/7")
3721 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x0000000c) 0x00000000/r32" "F - test-copy-byte-from-fn-arg/8")
3722 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-copy-byte-from-fn-arg/9")
3723 (check-next-stream-line-equal _test-output-stream " }" "F - test-copy-byte-from-fn-arg/10")
3724 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-copy-byte-from-fn-arg/11")
3725 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-copy-byte-from-fn-arg/12")
3726 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-copy-byte-from-fn-arg/13")
3727 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-copy-byte-from-fn-arg/14")
3728 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-copy-byte-from-fn-arg/15")
3729
3730 89/<- %esp 5/r32/ebp
3731 5d/pop-to-ebp
3732 c3/return
3733
3734 test-convert-compare-register-with-literal:
3735
3736 55/push-ebp
3737 89/<- %ebp 4/r32/esp
3738
3739 (clear-stream _test-input-stream)
3740 (clear-stream $_test-input-buffered-file->buffer)
3741 (clear-stream _test-output-stream)
3742 (clear-stream $_test-output-buffered-file->buffer)
3743
3744 (write _test-input-stream "fn foo {\n")
3745 (write _test-input-stream " var x/ecx: int <- copy 0\n")
3746 (write _test-input-stream " compare x, 0\n")
3747 (write _test-input-stream "}\n")
3748
3749 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
3750 (flush _test-output-buffered-file)
3751 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
3757
3758 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-compare-register-with-literal/0")
3759 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-compare-register-with-literal/1")
3760 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-compare-register-with-literal/2")
3761 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-compare-register-with-literal/3")
3762 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-compare-register-with-literal/4")
3763 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-compare-register-with-literal/5")
3764 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-compare-register-with-literal/6")
3765 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-compare-register-with-literal/7")
3766 (check-next-stream-line-equal _test-output-stream " 81 7/subop/compare %ecx 0/imm32" "F - test-convert-compare-register-with-literal/8")
3767 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-compare-register-with-literal/9")
3768 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-compare-register-with-literal/10")
3769 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-compare-register-with-literal/11")
3770 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-compare-register-with-literal/12")
3771 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-compare-register-with-literal/13")
3772 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-compare-register-with-literal/14")
3773 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-compare-register-with-literal/15")
3774
3775 89/<- %esp 5/r32/ebp
3776 5d/pop-to-ebp
3777 c3/return
3778
3779 test-unknown-variable:
3780
3781 55/push-ebp
3782 89/<- %ebp 4/r32/esp
3783
3784 (clear-stream _test-input-stream)
3785 (clear-stream $_test-input-buffered-file->buffer)
3786 (clear-stream _test-output-stream)
3787 (clear-stream $_test-output-buffered-file->buffer)
3788 (clear-stream _test-error-stream)
3789 (clear-stream $_test-error-buffered-file->buffer)
3790
3791 68/push 0/imm32
3792 68/push 0/imm32
3793 89/<- %edx 4/r32/esp
3794 (tailor-exit-descriptor %edx 0x10)
3795
3796 (write _test-input-stream "fn foo {\n")
3797 (write _test-input-stream " compare x, 0\n")
3798 (write _test-input-stream "}\n")
3799
3800 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
3801
3802
3803 89/<- %edx 4/r32/esp
3804 (flush _test-output-buffered-file)
3805 (flush _test-error-buffered-file)
3806 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
3812
3813 (check-stream-equal _test-output-stream "" "F - test-unknown-variable: output should be empty")
3814 (check-next-stream-line-equal _test-error-stream "fn foo: unknown variable 'x'" "F - test-unknown-variable: error message")
3815
3816 (check-ints-equal *(edx+4) 2 "F - test-unknown-variable: exit status")
3817
3818 81 0/subop/add %esp 8/imm32
3819
3820 5d/pop-to-ebp
3821 c3/return
3822
3823 test-convert-function-with-local-var-in-block:
3824
3825 55/push-ebp
3826 89/<- %ebp 4/r32/esp
3827
3828 (clear-stream _test-input-stream)
3829 (clear-stream $_test-input-buffered-file->buffer)
3830 (clear-stream _test-output-stream)
3831 (clear-stream $_test-output-buffered-file->buffer)
3832
3833 (write _test-input-stream "fn foo {\n")
3834 (write _test-input-stream " {\n")
3835 (write _test-input-stream " var x: int\n")
3836 (write _test-input-stream " increment x\n")
3837 (write _test-input-stream " }\n")
3838 (write _test-input-stream "}\n")
3839
3840 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
3841 (flush _test-output-buffered-file)
3842 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
3848
3849 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-block/0")
3850 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-block/1")
3851 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-block/2")
3852 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-block/3")
3853 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-block/4")
3854 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-block/5")
3855 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-block/6")
3856 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-local-var-in-block/7")
3857 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-block/8")
3858 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-block/9")
3859 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-block/10")
3860 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-block/11")
3861 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-local-var-in-block/12")
3862 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-block/13")
3863 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-block/14")
3864 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-block/15")
3865 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-block/16")
3866 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-block/17")
3867 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-block/18")
3868
3869 89/<- %esp 5/r32/ebp
3870 5d/pop-to-ebp
3871 c3/return
3872
3873 test-convert-function-with-local-var-in-mem-after-block:
3874
3875 55/push-ebp
3876 89/<- %ebp 4/r32/esp
3877
3878 (clear-stream _test-input-stream)
3879 (clear-stream $_test-input-buffered-file->buffer)
3880 (clear-stream _test-output-stream)
3881 (clear-stream $_test-output-buffered-file->buffer)
3882
3883 (write _test-input-stream "fn foo {\n")
3884 (write _test-input-stream " {\n")
3885 (write _test-input-stream " var y: int\n")
3886 (write _test-input-stream " }\n")
3887 (write _test-input-stream " var x: int\n")
3888 (write _test-input-stream " increment x\n")
3889 (write _test-input-stream "}\n")
3890
3891 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
3892 (flush _test-output-buffered-file)
3893 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
3899
3900 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-mem-after-block/0")
3901 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-mem-after-block/1")
3902 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-mem-after-block/2")
3903 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-mem-after-block/3")
3904 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-mem-after-block/4")
3905 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-mem-after-block/5")
3906 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-mem-after-block/6")
3907 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-local-var-in-mem-after-block/7")
3908 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-mem-after-block/8")
3909 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-mem-after-block/9")
3910 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-mem-after-block/10")
3911 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-local-var-in-mem-after-block/11")
3912 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-mem-after-block/12")
3913 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-mem-after-block/13")
3914 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-mem-after-block/14")
3915 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-mem-after-block/15")
3916 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-mem-after-block/16")
3917 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-mem-after-block/17")
3918 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-mem-after-block/18")
3919 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-mem-after-block/19")
3920 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-mem-after-block/20")
3921
3922 89/<- %esp 5/r32/ebp
3923 5d/pop-to-ebp
3924 c3/return
3925
3926 test-convert-function-with-local-var-in-named-block:
3927
3928 55/push-ebp
3929 89/<- %ebp 4/r32/esp
3930
3931 (clear-stream _test-input-stream)
3932 (clear-stream $_test-input-buffered-file->buffer)
3933 (clear-stream _test-output-stream)
3934 (clear-stream $_test-output-buffered-file->buffer)
3935
3936 (write _test-input-stream "fn foo {\n")
3937 (write _test-input-stream " $bar: {\n")
3938 (write _test-input-stream " var x: int\n")
3939 (write _test-input-stream " increment x\n")
3940 (write _test-input-stream " }\n")
3941 (write _test-input-stream "}\n")
3942
3943 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
3944 (flush _test-output-buffered-file)
3945 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
3951
3952 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-named-block/0")
3953 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-named-block/1")
3954 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-named-block/2")
3955 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-named-block/3")
3956 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-named-block/4")
3957 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-named-block/5")
3958 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-named-block/6")
3959 (check-next-stream-line-equal _test-output-stream "$bar:loop:" "F - test-convert-function-with-local-var-in-named-block/7")
3960 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-named-block/8")
3961 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-named-block/9")
3962 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-named-block/10")
3963 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-named-block/11")
3964 (check-next-stream-line-equal _test-output-stream "$bar:break:" "F - test-convert-function-with-local-var-in-named-block/12")
3965 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-named-block/13")
3966 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-named-block/14")
3967 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-named-block/15")
3968 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-named-block/16")
3969 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-named-block/17")
3970 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-named-block/18")
3971
3972 89/<- %esp 5/r32/ebp
3973 5d/pop-to-ebp
3974 c3/return
3975
3976 test-unknown-variable-in-named-block:
3977
3978 55/push-ebp
3979 89/<- %ebp 4/r32/esp
3980
3981 (clear-stream _test-input-stream)
3982 (clear-stream $_test-input-buffered-file->buffer)
3983 (clear-stream _test-output-stream)
3984 (clear-stream $_test-output-buffered-file->buffer)
3985 (clear-stream _test-error-stream)
3986 (clear-stream $_test-error-buffered-file->buffer)
3987
3988 68/push 0/imm32
3989 68/push 0/imm32
3990 89/<- %edx 4/r32/esp
3991 (tailor-exit-descriptor %edx 0x10)
3992
3993 (write _test-input-stream "fn foo {\n")
3994 (write _test-input-stream " $a: {\n")
3995 (write _test-input-stream " compare x, 0\n")
3996 (write _test-input-stream " }\n")
3997 (write _test-input-stream "}\n")
3998
3999 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
4000
4001
4002 89/<- %edx 4/r32/esp
4003 (flush _test-output-buffered-file)
4004 (flush _test-error-buffered-file)
4005 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
4011
4012 (check-stream-equal _test-output-stream "" "F - test-unknown-variable-in-named-block: output should be empty")
4013 (check-next-stream-line-equal _test-error-stream "fn foo: unknown variable 'x'" "F - test-unknown-variable-in-named-block: error message")
4014
4015 (check-ints-equal *(edx+4) 2 "F - test-unknown-variable-in-named-block: exit status")
4016
4017 81 0/subop/add %esp 8/imm32
4018
4019 5d/pop-to-ebp
4020 c3/return
4021
4022 test-always-shadow-outermost-reg-vars-in-function:
4023
4024 55/push-ebp
4025 89/<- %ebp 4/r32/esp
4026
4027 (clear-stream _test-input-stream)
4028 (clear-stream $_test-input-buffered-file->buffer)
4029 (clear-stream _test-output-stream)
4030 (clear-stream $_test-output-buffered-file->buffer)
4031
4032 (write _test-input-stream "fn foo {\n")
4033 (write _test-input-stream " var x/ecx: int <- copy 3\n")
4034 (write _test-input-stream "}\n")
4035
4036 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4037 (flush _test-output-buffered-file)
4038 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4044
4045 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-always-shadow-outermost-reg-vars-in-function/0")
4046 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-always-shadow-outermost-reg-vars-in-function/1")
4047 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-always-shadow-outermost-reg-vars-in-function/2")
4048 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-always-shadow-outermost-reg-vars-in-function/3")
4049 (check-next-stream-line-equal _test-output-stream " {" "F - test-always-shadow-outermost-reg-vars-in-function/4")
4050 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-always-shadow-outermost-reg-vars-in-function/5")
4051 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-compare-register-with-literal/6")
4052 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-always-shadow-outermost-reg-vars-in-function/8")
4053 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-compare-register-with-literal/9")
4054 (check-next-stream-line-equal _test-output-stream " }" "F - test-always-shadow-outermost-reg-vars-in-function/12")
4055 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-always-shadow-outermost-reg-vars-in-function/13")
4056 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-always-shadow-outermost-reg-vars-in-function/14")
4057 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-always-shadow-outermost-reg-vars-in-function/15")
4058 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-always-shadow-outermost-reg-vars-in-function/16")
4059 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-always-shadow-outermost-reg-vars-in-function/17")
4060
4061 89/<- %esp 5/r32/ebp
4062 5d/pop-to-ebp
4063 c3/return
4064
4065 test-shadow-local:
4066
4067 55/push-ebp
4068 89/<- %ebp 4/r32/esp
4069
4070 (clear-stream _test-input-stream)
4071 (clear-stream $_test-input-buffered-file->buffer)
4072 (clear-stream _test-output-stream)
4073 (clear-stream $_test-output-buffered-file->buffer)
4074
4075 (write _test-input-stream "fn foo {\n")
4076 (write _test-input-stream " var x/ecx: int <- copy 3\n")
4077 (write _test-input-stream " {\n")
4078 (write _test-input-stream " var y/ecx: int <- copy 4\n")
4079 (write _test-input-stream " }\n")
4080 (write _test-input-stream " x <- increment\n")
4081 (write _test-input-stream "}\n")
4082
4083 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4084 (flush _test-output-buffered-file)
4085 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4091
4092 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-local/0")
4093 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-local/1")
4094 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-local/2")
4095 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-local/3")
4096 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-local/4")
4097 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-local/5")
4098 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-local/6")
4099 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-local/7")
4100 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-local/8")
4101 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-local/9")
4102 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-local/10")
4103 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-shadow-local/11")
4104 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-local/12")
4105 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-local/13")
4106 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-local/14")
4107 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-local/15")
4108 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-local/16")
4109 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-local/17")
4110 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-local/18")
4111 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-local/19")
4112 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-local/20")
4113 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-local/21")
4114 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-local/22")
4115
4116 89/<- %esp 5/r32/ebp
4117 5d/pop-to-ebp
4118 c3/return
4119
4120 test-shadow-name:
4121
4122 55/push-ebp
4123 89/<- %ebp 4/r32/esp
4124
4125 (clear-stream _test-input-stream)
4126 (clear-stream $_test-input-buffered-file->buffer)
4127 (clear-stream _test-output-stream)
4128 (clear-stream $_test-output-buffered-file->buffer)
4129
4130 (write _test-input-stream "fn foo {\n")
4131 (write _test-input-stream " var x/ecx: int <- copy 3\n")
4132 (write _test-input-stream " {\n")
4133 (write _test-input-stream " var x/edx: int <- copy 4\n")
4134 (write _test-input-stream " }\n")
4135 (write _test-input-stream " x <- increment\n")
4136 (write _test-input-stream "}\n")
4137
4138 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4139 (flush _test-output-buffered-file)
4140 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4146
4147 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-name/0")
4148 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-name/1")
4149 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-name/2")
4150 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-name/3")
4151 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name/4")
4152 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-name/5")
4153 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name/6")
4154 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-name/7")
4155 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name/8")
4156 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-name/9")
4157 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-shadow-name/10")
4158 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 4/imm32" "F - test-shadow-name/11")
4159 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-shadow-name/12")
4160 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name/13")
4161 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-name/14")
4162 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-name/15")
4163 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name/16")
4164 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name/17")
4165 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-name/18")
4166 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-name/19")
4167 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-name/20")
4168 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-name/21")
4169 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-name/22")
4170
4171 89/<- %esp 5/r32/ebp
4172 5d/pop-to-ebp
4173 c3/return
4174
4175 test-shadow-name-2:
4176
4177 55/push-ebp
4178 89/<- %ebp 4/r32/esp
4179
4180 (clear-stream _test-input-stream)
4181 (clear-stream $_test-input-buffered-file->buffer)
4182 (clear-stream _test-output-stream)
4183 (clear-stream $_test-output-buffered-file->buffer)
4184
4185 (write _test-input-stream "fn foo {\n")
4186 (write _test-input-stream " var x/ecx: int <- copy 3\n")
4187 (write _test-input-stream " {\n")
4188 (write _test-input-stream " var x/edx: int <- copy 4\n")
4189 (write _test-input-stream " var y/ecx: int <- copy 5\n")
4190 (write _test-input-stream " }\n")
4191 (write _test-input-stream " x <- increment\n")
4192 (write _test-input-stream "}\n")
4193
4194 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4195 (flush _test-output-buffered-file)
4196 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4202
4203 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-name-2/0")
4204 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-name-2/1")
4205 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-name-2/2")
4206 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-name-2/3")
4207 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name-2/4")
4208 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-name-2/5")
4209 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name-2/6")
4210 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-name-2/7")
4211 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name-2/8")
4212 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-name-2/9")
4213 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-shadow-name-2/10")
4214 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 4/imm32" "F - test-shadow-name-2/11")
4215 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name-2/12")
4216 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 5/imm32" "F - test-shadow-name-2/13")
4217 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name-2/14")
4218 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-shadow-name-2/15")
4219 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name-2/16")
4220 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-name-2/17")
4221 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-name-2/18")
4222 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name-2/19")
4223 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name-2/20")
4224 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-name-2/21")
4225 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-name-2/22")
4226 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-name-2/23")
4227 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-name-2/24")
4228 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-name-2/25")
4229
4230 89/<- %esp 5/r32/ebp
4231 5d/pop-to-ebp
4232 c3/return
4233
4234 test-do-not-spill-same-register-in-block:
4235
4236 55/push-ebp
4237 89/<- %ebp 4/r32/esp
4238
4239 (clear-stream _test-input-stream)
4240 (clear-stream $_test-input-buffered-file->buffer)
4241 (clear-stream _test-output-stream)
4242 (clear-stream $_test-output-buffered-file->buffer)
4243
4244 (write _test-input-stream "fn foo {\n")
4245 (write _test-input-stream " var x/ecx: int <- copy 3\n")
4246 (write _test-input-stream " var y/ecx: int <- copy 4\n")
4247 (write _test-input-stream " y <- increment\n")
4248 (write _test-input-stream "}\n")
4249
4250 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4251 (flush _test-output-buffered-file)
4252 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4258
4259 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-do-not-spill-same-register-in-block/0")
4260 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-do-not-spill-same-register-in-block/1")
4261 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-do-not-spill-same-register-in-block/2")
4262 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-do-not-spill-same-register-in-block/3")
4263 (check-next-stream-line-equal _test-output-stream " {" "F - test-do-not-spill-same-register-in-block/4")
4264 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-do-not-spill-same-register-in-block/5")
4265 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-do-not-spill-same-register-in-block/6")
4266 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-do-not-spill-same-register-in-block/7")
4267 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-do-not-spill-same-register-in-block/8")
4268 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-do-not-spill-same-register-in-block/9")
4269 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-do-not-spill-same-register-in-block/10")
4270 (check-next-stream-line-equal _test-output-stream " }" "F - test-do-not-spill-same-register-in-block/11")
4271 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-do-not-spill-same-register-in-block/12")
4272 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-do-not-spill-same-register-in-block/13")
4273 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-do-not-spill-same-register-in-block/14")
4274 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-do-not-spill-same-register-in-block/15")
4275 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-do-not-spill-same-register-in-block/16")
4276
4277 89/<- %esp 5/r32/ebp
4278 5d/pop-to-ebp
4279 c3/return
4280
4281 test-spill-different-register-in-block:
4282
4283 55/push-ebp
4284 89/<- %ebp 4/r32/esp
4285
4286 (clear-stream _test-input-stream)
4287 (clear-stream $_test-input-buffered-file->buffer)
4288 (clear-stream _test-output-stream)
4289 (clear-stream $_test-output-buffered-file->buffer)
4290
4291 (write _test-input-stream "fn foo {\n")
4292 (write _test-input-stream " var x/eax: int <- copy 3\n")
4293 (write _test-input-stream " var y/ecx: int <- copy 4\n")
4294 (write _test-input-stream " y <- increment\n")
4295 (write _test-input-stream "}\n")
4296
4297 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4298 (flush _test-output-buffered-file)
4299 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4305
4306 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-spill-different-register-in-block/0")
4307 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-spill-different-register-in-block/1")
4308 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-spill-different-register-in-block/2")
4309 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-spill-different-register-in-block/3")
4310 (check-next-stream-line-equal _test-output-stream " {" "F - test-spill-different-register-in-block/4")
4311 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-spill-different-register-in-block/5")
4312 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-spill-different-register-in-block/6")
4313 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-spill-different-register-in-block/7")
4314 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-spill-different-register-in-block/8")
4315 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-spill-different-register-in-block/9")
4316 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-spill-different-register-in-block/10")
4317 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-spill-different-register-in-block/11")
4318 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-spill-different-register-in-block/12")
4319 (check-next-stream-line-equal _test-output-stream " }" "F - test-spill-different-register-in-block/13")
4320 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-spill-different-register-in-block/14")
4321 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-spill-different-register-in-block/15")
4322 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-spill-different-register-in-block/16")
4323 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-spill-different-register-in-block/17")
4324 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-spill-different-register-in-block/18")
4325
4326 89/<- %esp 5/r32/ebp
4327 5d/pop-to-ebp
4328 c3/return
4329
4330 test-convert-function-with-branches-in-block:
4331
4332 55/push-ebp
4333 89/<- %ebp 4/r32/esp
4334
4335 (clear-stream _test-input-stream)
4336 (clear-stream $_test-input-buffered-file->buffer)
4337 (clear-stream _test-output-stream)
4338 (clear-stream $_test-output-buffered-file->buffer)
4339
4340 (write _test-input-stream "fn foo x: int {\n")
4341 (write _test-input-stream " {\n")
4342 (write _test-input-stream " break-if->=\n")
4343 (write _test-input-stream " loop-if-addr<\n")
4344 (write _test-input-stream " increment x\n")
4345 (write _test-input-stream " loop\n")
4346 (write _test-input-stream " }\n")
4347 (write _test-input-stream "}\n")
4348
4349 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4350 (flush _test-output-buffered-file)
4351 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4357
4358 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-block/0")
4359 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-block/1")
4360 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-in-block/2")
4361 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-in-block/3")
4362 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/4")
4363 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-in-block/5")
4364 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/6")
4365 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-in-block/7")
4366 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/8")
4367 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-in-block/9")
4368 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-in-block/10")
4369 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/11")
4370 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/12")
4371 (check-next-stream-line-equal _test-output-stream " 0f 83/jump-if-addr>= break/disp32" "F - test-convert-function-with-branches-in-block/13")
4372 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:loop/disp32" "F - test-convert-function-with-branches-in-block/14")
4373 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/15")
4374 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-branches-in-block/16")
4375 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-in-block/17")
4376 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/18")
4377 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-in-block/19")
4378 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/20")
4379 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-in-block/21")
4380 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-in-block/22")
4381 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-in-block/23")
4382 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-in-block/24")
4383 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-in-block/25")
4384
4385 89/<- %esp 5/r32/ebp
4386 5d/pop-to-ebp
4387 c3/return
4388
4389 test-convert-function-with-branches-in-block-2:
4390
4391 55/push-ebp
4392 89/<- %ebp 4/r32/esp
4393
4394 (clear-stream _test-input-stream)
4395 (clear-stream $_test-input-buffered-file->buffer)
4396 (clear-stream _test-output-stream)
4397 (clear-stream $_test-output-buffered-file->buffer)
4398
4399 (write _test-input-stream "fn foo x: int {\n")
4400 (write _test-input-stream " {\n")
4401 (write _test-input-stream " break-if->=\n")
4402 (write _test-input-stream " loop-if-float<\n")
4403 (write _test-input-stream " increment x\n")
4404 (write _test-input-stream " loop\n")
4405 (write _test-input-stream " }\n")
4406 (write _test-input-stream "}\n")
4407
4408 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4409 (flush _test-output-buffered-file)
4410 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4416
4417 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-block/0")
4418 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-block/1")
4419 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-in-block/2")
4420 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-in-block/3")
4421 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/4")
4422 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-in-block/5")
4423 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/6")
4424 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-in-block/7")
4425 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/8")
4426 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-in-block/9")
4427 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-in-block/10")
4428 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/11")
4429 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/12")
4430 (check-next-stream-line-equal _test-output-stream " 0f 83/jump-if-addr>= break/disp32" "F - test-convert-function-with-branches-in-block/13")
4431 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:loop/disp32" "F - test-convert-function-with-branches-in-block/14")
4432 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/15")
4433 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-branches-in-block/16")
4434 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-in-block/17")
4435 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/18")
4436 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-in-block/19")
4437 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/20")
4438 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-in-block/21")
4439 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-in-block/22")
4440 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-in-block/23")
4441 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-in-block/24")
4442 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-in-block/25")
4443
4444 89/<- %esp 5/r32/ebp
4445 5d/pop-to-ebp
4446 c3/return
4447
4448 test-convert-function-with-branches-in-named-block:
4449
4450 55/push-ebp
4451 89/<- %ebp 4/r32/esp
4452
4453 (clear-stream _test-input-stream)
4454 (clear-stream $_test-input-buffered-file->buffer)
4455 (clear-stream _test-output-stream)
4456 (clear-stream $_test-output-buffered-file->buffer)
4457
4458 (write _test-input-stream "fn foo x: int {\n")
4459 (write _test-input-stream " $bar: {\n")
4460 (write _test-input-stream " break-if->= $bar\n")
4461 (write _test-input-stream " loop-if-addr< $bar\n")
4462 (write _test-input-stream " increment x\n")
4463 (write _test-input-stream " loop\n")
4464 (write _test-input-stream " }\n")
4465 (write _test-input-stream "}\n")
4466
4467 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4468 (flush _test-output-buffered-file)
4469 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4475
4476 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-named-block/0")
4477 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-named-block/1")
4478 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-in-named-block/2")
4479 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-in-named-block/3")
4480 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/4")
4481 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-in-named-block/5")
4482 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/6")
4483 (check-next-stream-line-equal _test-output-stream "$bar:loop:" "F - test-convert-function-with-branches-in-named-block/7")
4484 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/8")
4485 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-in-named-block/9")
4486 (check-next-stream-line-equal _test-output-stream " e9/jump $bar:break/disp32" "F - test-convert-function-with-branches-in-named-block/10")
4487 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/11")
4488 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/12")
4489 (check-next-stream-line-equal _test-output-stream " 0f 83/jump-if-addr>= break/disp32" "F - test-convert-function-with-branches-in-named-block/13")
4490 (check-next-stream-line-equal _test-output-stream " e9/jump $bar:loop/disp32" "F - test-convert-function-with-branches-in-named-block/14")
4491 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/15")
4492 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-branches-in-named-block/16")
4493 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-in-named-block/17")
4494 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/18")
4495 (check-next-stream-line-equal _test-output-stream "$bar:break:" "F - test-convert-function-with-branches-in-named-block/19")
4496 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/20")
4497 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-in-named-block/21")
4498 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-in-named-block/22")
4499 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-in-named-block/23")
4500 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-in-named-block/24")
4501 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-in-named-block/25")
4502
4503 89/<- %esp 5/r32/ebp
4504 5d/pop-to-ebp
4505 c3/return
4506
4507 test-convert-function-with-var-in-nested-block:
4508
4509 55/push-ebp
4510 89/<- %ebp 4/r32/esp
4511
4512 (clear-stream _test-input-stream)
4513 (clear-stream $_test-input-buffered-file->buffer)
4514 (clear-stream _test-output-stream)
4515 (clear-stream $_test-output-buffered-file->buffer)
4516
4517 (write _test-input-stream "fn foo x: int {\n")
4518 (write _test-input-stream " {\n")
4519 (write _test-input-stream " {\n")
4520 (write _test-input-stream " var x: int\n")
4521 (write _test-input-stream " increment x\n")
4522 (write _test-input-stream " }\n")
4523 (write _test-input-stream " }\n")
4524 (write _test-input-stream "}\n")
4525
4526 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4527 (flush _test-output-buffered-file)
4528 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4534
4535 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-var-in-nested-block/0")
4536 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-var-in-nested-block/1")
4537 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-var-in-nested-block/2")
4538 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-var-in-nested-block/3")
4539 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/4")
4540 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-var-in-nested-block/5")
4541 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/6")
4542 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-var-in-nested-block/7")
4543 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/8")
4544 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-var-in-nested-block/9")
4545 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-var-in-nested-block/10")
4546 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-var-in-nested-block/11")
4547 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-var-in-nested-block/12")
4548 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/13")
4549 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-var-in-nested-block/14")
4550 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/15")
4551 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-var-in-nested-block/16")
4552 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/17")
4553 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-var-in-nested-block/18")
4554 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-var-in-nested-block/19")
4555 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-var-in-nested-block/20")
4556 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-var-in-nested-block/21")
4557 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-var-in-nested-block/22")
4558
4559 89/<- %esp 5/r32/ebp
4560 5d/pop-to-ebp
4561 c3/return
4562
4563 test-convert-function-with-multiple-vars-in-nested-blocks:
4564
4565 55/push-ebp
4566 89/<- %ebp 4/r32/esp
4567
4568 (clear-stream _test-input-stream)
4569 (clear-stream $_test-input-buffered-file->buffer)
4570 (clear-stream _test-output-stream)
4571 (clear-stream $_test-output-buffered-file->buffer)
4572
4573 (write _test-input-stream "fn foo x: int {\n")
4574 (write _test-input-stream " {\n")
4575 (write _test-input-stream " var x/eax: int <- copy 0\n")
4576 (write _test-input-stream " {\n")
4577 (write _test-input-stream " var y: int\n")
4578 (write _test-input-stream " x <- add y\n")
4579 (write _test-input-stream " }\n")
4580 (write _test-input-stream " }\n")
4581 (write _test-input-stream "}\n")
4582
4583 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4584 (flush _test-output-buffered-file)
4585 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4591
4592 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/0")
4593 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-multiple-vars-in-nested-blocks/1")
4594 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/2")
4595 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/3")
4596 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/4")
4597 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/5")
4598 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/6")
4599 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/7")
4600 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-multiple-vars-in-nested-blocks/8")
4601 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/9")
4602 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/10")
4603 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/11")
4604 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/12")
4605 (check-next-stream-line-equal _test-output-stream " 03/add *(ebp+0xfffffff8) 0x00000000/r32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/13")
4606 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/14")
4607 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/15")
4608 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/16")
4609 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-multiple-vars-in-nested-blocks/17")
4610 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/18")
4611 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/19")
4612 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/20")
4613 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/21")
4614 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-multiple-vars-in-nested-blocks/22")
4615 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/23")
4616 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/24")
4617 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-multiple-vars-in-nested-blocks/25")
4618
4619 89/<- %esp 5/r32/ebp
4620 5d/pop-to-ebp
4621 c3/return
4622
4623 test-convert-function-with-branches-and-local-vars:
4624
4625
4626
4627
4628 55/push-ebp
4629 89/<- %ebp 4/r32/esp
4630
4631 (clear-stream _test-input-stream)
4632 (clear-stream $_test-input-buffered-file->buffer)
4633 (clear-stream _test-output-stream)
4634 (clear-stream $_test-output-buffered-file->buffer)
4635
4636 (write _test-input-stream "fn foo {\n")
4637 (write _test-input-stream " {\n")
4638 (write _test-input-stream " var x: int\n")
4639 (write _test-input-stream " break-if->=\n")
4640 (write _test-input-stream " increment x\n")
4641 (write _test-input-stream " }\n")
4642 (write _test-input-stream "}\n")
4643
4644 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4645 (flush _test-output-buffered-file)
4646 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4652
4653 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-and-local-vars/0")
4654 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-and-local-vars/1")
4655 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-and-local-vars/2")
4656 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-and-local-vars/3")
4657 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/4")
4658 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-and-local-vars/5")
4659 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/6")
4660 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-and-local-vars/7")
4661 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-branches-and-local-vars/8")
4662 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/9")
4663 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-and-local-vars/10")
4664 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-local-vars/11")
4665 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-and-local-vars/12")
4666 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/13")
4667 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-branches-and-local-vars/14")
4668 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-local-vars/15")
4669 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/16")
4670 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-and-local-vars/17")
4671 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/18")
4672 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-and-local-vars/19")
4673 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-and-local-vars/20")
4674 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-and-local-vars/21")
4675 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-and-local-vars/22")
4676 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-and-local-vars/23")
4677
4678 89/<- %esp 5/r32/ebp
4679 5d/pop-to-ebp
4680 c3/return
4681
4682 test-convert-function-with-conditional-loops-and-local-vars:
4683
4684
4685
4686
4687 55/push-ebp
4688 89/<- %ebp 4/r32/esp
4689
4690 (clear-stream _test-input-stream)
4691 (clear-stream $_test-input-buffered-file->buffer)
4692 (clear-stream _test-output-stream)
4693 (clear-stream $_test-output-buffered-file->buffer)
4694
4695 (write _test-input-stream "fn foo {\n")
4696 (write _test-input-stream " {\n")
4697 (write _test-input-stream " var x: int\n")
4698 (write _test-input-stream " loop-if->=\n")
4699 (write _test-input-stream " increment x\n")
4700 (write _test-input-stream " }\n")
4701 (write _test-input-stream "}\n")
4702
4703 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4704 (flush _test-output-buffered-file)
4705 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4711
4712 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-conditional-loops-and-local-vars/0")
4713 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-conditional-loops-and-local-vars/1")
4714 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/2")
4715 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-conditional-loops-and-local-vars/3")
4716 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/4")
4717 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-conditional-loops-and-local-vars/5")
4718 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/6")
4719 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-conditional-loops-and-local-vars/7")
4720 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/8")
4721 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/9")
4722 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-conditional-loops-and-local-vars/10")
4723 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/11")
4724 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:loop/disp32" "F - test-convert-function-with-conditional-loops-and-local-vars/12")
4725 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/13")
4726 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-conditional-loops-and-local-vars/14")
4727 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/15")
4728 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/16")
4729 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-conditional-loops-and-local-vars/17")
4730 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/18")
4731 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-conditional-loops-and-local-vars/19")
4732 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-conditional-loops-and-local-vars/20")
4733 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/21")
4734 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/22")
4735 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-conditional-loops-and-local-vars/23")
4736
4737 89/<- %esp 5/r32/ebp
4738 5d/pop-to-ebp
4739 c3/return
4740
4741 test-convert-function-with-unconditional-loops-and-local-vars:
4742
4743
4744
4745
4746 55/push-ebp
4747 89/<- %ebp 4/r32/esp
4748
4749 (clear-stream _test-input-stream)
4750 (clear-stream $_test-input-buffered-file->buffer)
4751 (clear-stream _test-output-stream)
4752 (clear-stream $_test-output-buffered-file->buffer)
4753
4754 (write _test-input-stream "fn foo {\n")
4755 (write _test-input-stream " {\n")
4756 (write _test-input-stream " var x: int\n")
4757 (write _test-input-stream " loop\n")
4758 (write _test-input-stream " increment x\n")
4759 (write _test-input-stream " }\n")
4760 (write _test-input-stream "}\n")
4761
4762 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4763 (flush _test-output-buffered-file)
4764 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4770
4771 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-unconditional-loops-and-local-vars/0")
4772 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-unconditional-loops-and-local-vars/1")
4773 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/2")
4774 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-unconditional-loops-and-local-vars/3")
4775 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-loops-and-local-vars/4")
4776 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-unconditional-loops-and-local-vars/5")
4777 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-loops-and-local-vars/6")
4778 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-unconditional-loops-and-local-vars/7")
4779 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-loops-and-local-vars/8")
4780 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-loops-and-local-vars/9")
4781 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-unconditional-loops-and-local-vars/10")
4782
4783 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-loops-and-local-vars/11")
4784 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-unconditional-loops-and-local-vars/12")
4785 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-loops-and-local-vars/13")
4786 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-unconditional-loops-and-local-vars/14")
4787 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-unconditional-loops-and-local-vars/15")
4788 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/16")
4789 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/17")
4790 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-unconditional-loops-and-local-vars/18")
4791
4792 89/<- %esp 5/r32/ebp
4793 5d/pop-to-ebp
4794 c3/return
4795
4796 test-convert-function-with-branches-and-loops-and-local-vars:
4797
4798 55/push-ebp
4799 89/<- %ebp 4/r32/esp
4800
4801 (clear-stream _test-input-stream)
4802 (clear-stream $_test-input-buffered-file->buffer)
4803 (clear-stream _test-output-stream)
4804 (clear-stream $_test-output-buffered-file->buffer)
4805
4806 (write _test-input-stream "fn foo {\n")
4807 (write _test-input-stream " {\n")
4808 (write _test-input-stream " var x: int\n")
4809 (write _test-input-stream " break-if->=\n")
4810 (write _test-input-stream " increment x\n")
4811 (write _test-input-stream " loop\n")
4812 (write _test-input-stream " }\n")
4813 (write _test-input-stream "}\n")
4814
4815 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4816 (flush _test-output-buffered-file)
4817 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4823
4824 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-and-loops-and-local-vars/0")
4825 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-and-loops-and-local-vars/1")
4826 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/2")
4827 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-and-loops-and-local-vars/3")
4828 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/4")
4829 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-and-loops-and-local-vars/5")
4830 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/6")
4831 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-and-loops-and-local-vars/7")
4832 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/8")
4833 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/9")
4834 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/10")
4835 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/11")
4836 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/12")
4837 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/13")
4838 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-branches-and-loops-and-local-vars/14")
4839 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/15")
4840 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/16")
4841 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/17")
4842 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-and-loops-and-local-vars/18")
4843 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/19")
4844 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-and-loops-and-local-vars/20")
4845 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-and-loops-and-local-vars/21")
4846 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/22")
4847 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/23")
4848 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-and-loops-and-local-vars/24")
4849
4850 89/<- %esp 5/r32/ebp
4851 5d/pop-to-ebp
4852 c3/return
4853
4854 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars:
4855
4856 55/push-ebp
4857 89/<- %ebp 4/r32/esp
4858
4859 (clear-stream _test-input-stream)
4860 (clear-stream $_test-input-buffered-file->buffer)
4861 (clear-stream _test-output-stream)
4862 (clear-stream $_test-output-buffered-file->buffer)
4863
4864 (write _test-input-stream "fn foo {\n")
4865 (write _test-input-stream " a: {\n")
4866 (write _test-input-stream " var x: int\n")
4867 (write _test-input-stream " {\n")
4868 (write _test-input-stream " var y: int\n")
4869 (write _test-input-stream " break-if->= a\n")
4870 (write _test-input-stream " increment x\n")
4871 (write _test-input-stream " loop\n")
4872 (write _test-input-stream " }\n")
4873 (write _test-input-stream " }\n")
4874 (write _test-input-stream "}\n")
4875
4876 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4877 (flush _test-output-buffered-file)
4878 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4884
4885 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/0")
4886 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/1")
4887 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/2")
4888 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/3")
4889 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/4")
4890 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/5")
4891 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/6")
4892 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/7")
4893 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/8")
4894 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/9")
4895 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/10")
4896 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/11")
4897 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/12")
4898 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/13")
4899 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/14")
4900 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/15")
4901 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/16")
4902 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/17")
4903 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/18")
4904 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/19")
4905 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/20")
4906 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/21")
4907 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/22")
4908 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/23")
4909 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/24")
4910 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/25")
4911 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/26")
4912 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/27")
4913 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/28")
4914 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/29")
4915 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/30")
4916 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/31")
4917
4918 89/<- %esp 5/r32/ebp
4919 5d/pop-to-ebp
4920 c3/return
4921
4922 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2:
4923
4924 55/push-ebp
4925 89/<- %ebp 4/r32/esp
4926
4927 (clear-stream _test-input-stream)
4928 (clear-stream $_test-input-buffered-file->buffer)
4929 (clear-stream _test-output-stream)
4930 (clear-stream $_test-output-buffered-file->buffer)
4931
4932
4933 (write _test-input-stream "fn foo {\n")
4934 (write _test-input-stream " a: {\n")
4935 (write _test-input-stream " var x: int\n")
4936 (write _test-input-stream " {\n")
4937 (write _test-input-stream " break-if->= a\n")
4938 (write _test-input-stream " }\n")
4939 (write _test-input-stream " }\n")
4940 (write _test-input-stream "}\n")
4941
4942 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
4943 (flush _test-output-buffered-file)
4944 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
4950
4951 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/0")
4952 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/1")
4953 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/2")
4954 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/3")
4955 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/4")
4956 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/5")
4957 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/6")
4958 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/7")
4959 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/8")
4960 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/9")
4961 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/10")
4962 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/11")
4963 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/12")
4964 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/13")
4965 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/14")
4966 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/15")
4967 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/16")
4968 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/17")
4969 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/18")
4970 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/19")
4971 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/20")
4972 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/21")
4973 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/22")
4974 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/23")
4975 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/24")
4976 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/25")
4977 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/26")
4978
4979 89/<- %esp 5/r32/ebp
4980 5d/pop-to-ebp
4981 c3/return
4982
4983 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3:
4984
4985 55/push-ebp
4986 89/<- %ebp 4/r32/esp
4987
4988 (clear-stream _test-input-stream)
4989 (clear-stream $_test-input-buffered-file->buffer)
4990 (clear-stream _test-output-stream)
4991 (clear-stream $_test-output-buffered-file->buffer)
4992
4993
4994 (write _test-input-stream "fn foo {\n")
4995 (write _test-input-stream " a: {\n")
4996 (write _test-input-stream " var x: int\n")
4997 (write _test-input-stream " {\n")
4998 (write _test-input-stream " break a\n")
4999 (write _test-input-stream " }\n")
5000 (write _test-input-stream " }\n")
5001 (write _test-input-stream "}\n")
5002
5003 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5004 (flush _test-output-buffered-file)
5005 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5011
5012 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/0")
5013 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/1")
5014 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/2")
5015 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/3")
5016 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/4")
5017 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/5")
5018 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/6")
5019 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/7")
5020 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/8")
5021 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/9")
5022 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/10")
5023 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/11")
5024 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/12")
5025 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/14")
5026 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/15")
5027 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/16")
5028 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/17")
5029 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/18")
5030 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/19")
5031 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/20")
5032 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/21")
5033 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/22")
5034 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/23")
5035 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/24")
5036
5037 89/<- %esp 5/r32/ebp
5038 5d/pop-to-ebp
5039 c3/return
5040
5041 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4:
5042
5043 55/push-ebp
5044 89/<- %ebp 4/r32/esp
5045
5046 (clear-stream _test-input-stream)
5047 (clear-stream $_test-input-buffered-file->buffer)
5048 (clear-stream _test-output-stream)
5049 (clear-stream $_test-output-buffered-file->buffer)
5050
5051 (write _test-input-stream "fn foo {\n")
5052 (write _test-input-stream " a: {\n")
5053 (write _test-input-stream " var x/esi: int <- copy 0\n")
5054 (write _test-input-stream " {\n")
5055 (write _test-input-stream " break a\n")
5056 (write _test-input-stream " }\n")
5057 (write _test-input-stream " }\n")
5058 (write _test-input-stream "}\n")
5059
5060 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5061 (flush _test-output-buffered-file)
5062 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5068
5069 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/0")
5070 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/1")
5071 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/2")
5072 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/3")
5073 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/4")
5074 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/5")
5075 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/6")
5076 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/7")
5077 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/8")
5078 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/9")
5079 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/10")
5080 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/11")
5081 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/12")
5082 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/13")
5083 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/14")
5084 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/15")
5085 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/16")
5086 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/17")
5087 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/18")
5088 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/19")
5089 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/20")
5090 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/21")
5091 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/22")
5092 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/23")
5093 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/24")
5094
5095 89/<- %esp 5/r32/ebp
5096 5d/pop-to-ebp
5097 c3/return
5098
5099 test-convert-function-with-nonlocal-unconditional-break-and-local-vars:
5100
5101 55/push-ebp
5102 89/<- %ebp 4/r32/esp
5103
5104 (clear-stream _test-input-stream)
5105 (clear-stream $_test-input-buffered-file->buffer)
5106 (clear-stream _test-output-stream)
5107 (clear-stream $_test-output-buffered-file->buffer)
5108
5109 (write _test-input-stream "fn foo {\n")
5110 (write _test-input-stream " a: {\n")
5111 (write _test-input-stream " var x: int\n")
5112 (write _test-input-stream " {\n")
5113 (write _test-input-stream " var y: int\n")
5114 (write _test-input-stream " break a\n")
5115 (write _test-input-stream " increment x\n")
5116 (write _test-input-stream " }\n")
5117 (write _test-input-stream " }\n")
5118 (write _test-input-stream "}\n")
5119
5120 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5121 (flush _test-output-buffered-file)
5122 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5128
5129 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/0")
5130 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/1")
5131 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/2")
5132 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/3")
5133 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/4")
5134 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/5")
5135 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/6")
5136 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/7")
5137 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/8")
5138 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/9")
5139 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/10")
5140 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/11")
5141 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/12")
5142 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/13")
5143 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/14")
5144 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/15")
5145 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/16")
5146 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/17")
5147 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/18")
5148 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/19")
5149 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/20")
5150 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/21")
5151 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/22")
5152 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/23")
5153 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/24")
5154 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/25")
5155
5156 89/<- %esp 5/r32/ebp
5157 5d/pop-to-ebp
5158 c3/return
5159
5160 test-convert-function-with-unconditional-break-and-local-vars:
5161
5162 55/push-ebp
5163 89/<- %ebp 4/r32/esp
5164
5165 (clear-stream _test-input-stream)
5166 (clear-stream $_test-input-buffered-file->buffer)
5167 (clear-stream _test-output-stream)
5168 (clear-stream $_test-output-buffered-file->buffer)
5169
5170 (write _test-input-stream "fn foo {\n")
5171 (write _test-input-stream " {\n")
5172 (write _test-input-stream " var x: int\n")
5173 (write _test-input-stream " {\n")
5174 (write _test-input-stream " var y: int\n")
5175 (write _test-input-stream " break\n")
5176 (write _test-input-stream " increment x\n")
5177 (write _test-input-stream " }\n")
5178 (write _test-input-stream " }\n")
5179 (write _test-input-stream "}\n")
5180
5181 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5182 (flush _test-output-buffered-file)
5183 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5189
5190 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-unconditional-break-and-local-vars/0")
5191 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-unconditional-break-and-local-vars/1")
5192 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/2")
5193 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-unconditional-break-and-local-vars/3")
5194 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/4")
5195 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/5")
5196 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/6")
5197 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/7")
5198 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/8")
5199 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/9")
5200 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/10")
5201 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/11")
5202 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/12")
5203 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/13")
5204 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/14")
5205 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/15")
5206 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/16")
5207 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/17")
5208 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/18")
5209 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/19")
5210 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-unconditional-break-and-local-vars/20")
5211 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/21")
5212 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/22")
5213 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-unconditional-break-and-local-vars/23")
5214
5215 89/<- %esp 5/r32/ebp
5216 5d/pop-to-ebp
5217 c3/return
5218
5219 test-convert-function-with-nonlocal-unconditional-loop-and-local-vars:
5220
5221 55/push-ebp
5222 89/<- %ebp 4/r32/esp
5223
5224 (clear-stream _test-input-stream)
5225 (clear-stream $_test-input-buffered-file->buffer)
5226 (clear-stream _test-output-stream)
5227 (clear-stream $_test-output-buffered-file->buffer)
5228
5229 (write _test-input-stream "fn foo {\n")
5230 (write _test-input-stream " a: {\n")
5231 (write _test-input-stream " var x: int\n")
5232 (write _test-input-stream " {\n")
5233 (write _test-input-stream " var y: int\n")
5234 (write _test-input-stream " loop a\n")
5235 (write _test-input-stream " increment x\n")
5236 (write _test-input-stream " }\n")
5237 (write _test-input-stream " }\n")
5238 (write _test-input-stream "}\n")
5239
5240 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5241 (flush _test-output-buffered-file)
5242 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5248
5249 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/0")
5250 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/1")
5251 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/2")
5252 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/3")
5253 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/4")
5254 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/5")
5255 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/6")
5256 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/7")
5257 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/8")
5258 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/9")
5259 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/10")
5260 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/11")
5261 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/12")
5262 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/13")
5263 (check-next-stream-line-equal _test-output-stream " e9/jump a:loop/disp32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/14")
5264 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/15")
5265 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/16")
5266 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/17")
5267 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/18")
5268 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/19")
5269 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/20")
5270 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/21")
5271 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/22")
5272 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/23")
5273 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/24")
5274 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/25")
5275
5276 89/<- %esp 5/r32/ebp
5277 5d/pop-to-ebp
5278 c3/return
5279
5280 test-convert-function-with-local-array-var-in-mem:
5281
5282 55/push-ebp
5283 89/<- %ebp 4/r32/esp
5284
5285 (clear-stream _test-input-stream)
5286 (clear-stream $_test-input-buffered-file->buffer)
5287 (clear-stream _test-output-stream)
5288 (clear-stream $_test-output-buffered-file->buffer)
5289
5290 (write _test-input-stream "fn foo {\n")
5291 (write _test-input-stream " var x: (array int 3)\n")
5292 (write _test-input-stream "}\n")
5293
5294 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5295 (flush _test-output-buffered-file)
5296 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5302
5303 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-array-var-in-mem/0")
5304 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-array-var-in-mem/1")
5305 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-array-var-in-mem/2")
5306 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-array-var-in-mem/3")
5307 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-array-var-in-mem/4")
5308 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-array-var-in-mem/5")
5309
5310 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-function-with-local-array-var-in-mem/7")
5311 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-function-with-local-array-var-in-mem/8")
5312
5313 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-function-with-local-array-var-in-mem/9")
5314
5315 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-array-var-in-mem/10")
5316 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-array-var-in-mem/11")
5317 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-array-var-in-mem/12")
5318 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-array-var-in-mem/13")
5319 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-array-var-in-mem/14")
5320 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-array-var-in-mem/15")
5321
5322 89/<- %esp 5/r32/ebp
5323 5d/pop-to-ebp
5324 c3/return
5325
5326 test-array-size-in-hex:
5327
5328 55/push-ebp
5329 89/<- %ebp 4/r32/esp
5330
5331 (clear-stream _test-input-stream)
5332 (clear-stream $_test-input-buffered-file->buffer)
5333 (clear-stream _test-output-stream)
5334 (clear-stream $_test-output-buffered-file->buffer)
5335 (clear-stream _test-error-stream)
5336 (clear-stream $_test-error-buffered-file->buffer)
5337
5338 68/push 0/imm32
5339 68/push 0/imm32
5340 89/<- %edx 4/r32/esp
5341 (tailor-exit-descriptor %edx 0x10)
5342
5343 (write _test-input-stream "fn foo {\n")
5344 (write _test-input-stream " var x: (array int 10)\n")
5345 (write _test-input-stream "}\n")
5346
5347 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
5348
5349
5350 89/<- %edx 4/r32/esp
5351 (flush _test-output-buffered-file)
5352 (flush _test-error-buffered-file)
5353 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
5359
5360 (check-stream-equal _test-output-stream "" "F - test-array-size-in-hex: output should be empty")
5361 (check-next-stream-line-equal _test-error-stream "literal integers are always hex in Mu; start '10' with a '0x' to be unambiguous, converting it to hexadecimal as necessary." "F - test-array-size-in-hex: error message")
5362
5363 (check-ints-equal *(edx+4) 2 "F - test-array-size-in-hex: exit status")
5364
5365 81 0/subop/add %esp 8/imm32
5366
5367 5d/pop-to-ebp
5368 c3/return
5369
5370 test-convert-function-with-populate:
5371
5372 55/push-ebp
5373 89/<- %ebp 4/r32/esp
5374
5375 (clear-stream _test-input-stream)
5376 (clear-stream $_test-input-buffered-file->buffer)
5377 (clear-stream _test-output-stream)
5378 (clear-stream $_test-output-buffered-file->buffer)
5379
5380 (write _test-input-stream "fn foo {\n")
5381 (write _test-input-stream " var x/ecx: (addr handle array int) <- copy 0\n")
5382 (write _test-input-stream " populate x, 7\n")
5383 (write _test-input-stream "}\n")
5384
5385 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5386 (flush _test-output-buffered-file)
5387 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5393
5394 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-populate/0")
5395 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-populate/1")
5396 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-populate/2")
5397 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-populate/3")
5398 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-populate/4")
5399 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-populate/5")
5400 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-populate/6")
5401 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-populate/7")
5402 (check-next-stream-line-equal _test-output-stream " (allocate-array2 Heap 0x00000004 7 %ecx)" "F - test-convert-function-with-populate/8")
5403 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-populate/9")
5404 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-populate/10")
5405 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-populate/11")
5406 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-populate/12")
5407 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-populate/13")
5408 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-populate/14")
5409 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-populate/15")
5410
5411 89/<- %esp 5/r32/ebp
5412 5d/pop-to-ebp
5413 c3/return
5414
5415
5416 test-convert-function-with-local-array-of-bytes-in-mem:
5417
5418 55/push-ebp
5419 89/<- %ebp 4/r32/esp
5420
5421 (clear-stream _test-input-stream)
5422 (clear-stream $_test-input-buffered-file->buffer)
5423 (clear-stream _test-output-stream)
5424 (clear-stream $_test-output-buffered-file->buffer)
5425
5426 (write _test-input-stream "fn foo {\n")
5427 (write _test-input-stream " var x: (array byte 3)\n")
5428 (write _test-input-stream "}\n")
5429
5430 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5431 (flush _test-output-buffered-file)
5432 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5438
5439 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-array-of-bytes-in-mem/0")
5440 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-array-of-bytes-in-mem/1")
5441 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/2")
5442 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-array-of-bytes-in-mem/3")
5443 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-array-of-bytes-in-mem/4")
5444 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-array-of-bytes-in-mem/5")
5445
5446 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x00000003)" "F - test-convert-function-with-local-array-of-bytes-in-mem/7")
5447 (check-next-stream-line-equal _test-output-stream " 68/push 0x00000003/imm32" "F - test-convert-function-with-local-array-of-bytes-in-mem/8")
5448
5449 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000007/imm32" "F - test-convert-function-with-local-array-of-bytes-in-mem/9")
5450
5451 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-array-of-bytes-in-mem/10")
5452 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-array-of-bytes-in-mem/11")
5453 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-array-of-bytes-in-mem/12")
5454 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/13")
5455 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/14")
5456 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-array-of-bytes-in-mem/15")
5457
5458 89/<- %esp 5/r32/ebp
5459 5d/pop-to-ebp
5460 c3/return
5461
5462 test-convert-address:
5463
5464 55/push-ebp
5465 89/<- %ebp 4/r32/esp
5466
5467 (clear-stream _test-input-stream)
5468 (clear-stream $_test-input-buffered-file->buffer)
5469 (clear-stream _test-output-stream)
5470 (clear-stream $_test-output-buffered-file->buffer)
5471
5472 (write _test-input-stream "fn foo {\n")
5473 (write _test-input-stream " var a: int\n")
5474 (write _test-input-stream " var b/eax: (addr int) <- address a\n")
5475 (write _test-input-stream "}\n")
5476
5477 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5478 (flush _test-output-buffered-file)
5479 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5485
5486 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-address/0")
5487 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-address/1")
5488 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-address/2")
5489 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-address/3")
5490 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-address/4")
5491 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-address/5")
5492 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-address/6")
5493 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-address/7")
5494 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffffc) 0x00000000/r32" "F - test-convert-address/8")
5495 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-address/9")
5496 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-address/10")
5497 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-address/11")
5498 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-address/12")
5499 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-address/13")
5500 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-address/14")
5501 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-address/15")
5502 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-address/16")
5503
5504 89/<- %esp 5/r32/ebp
5505 5d/pop-to-ebp
5506 c3/return
5507
5508 test-convert-floating-point-convert:
5509
5510 55/push-ebp
5511 89/<- %ebp 4/r32/esp
5512
5513 (clear-stream _test-input-stream)
5514 (clear-stream $_test-input-buffered-file->buffer)
5515 (clear-stream _test-output-stream)
5516 (clear-stream $_test-output-buffered-file->buffer)
5517
5518 (write _test-input-stream "fn foo {\n")
5519 (write _test-input-stream " var a/eax: int <- copy 0\n")
5520 (write _test-input-stream " var b/xmm1: float <- convert a\n")
5521 (write _test-input-stream "}\n")
5522
5523 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5524 (flush _test-output-buffered-file)
5525 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5531
5532 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-floating-point-convert/0")
5533 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-floating-point-convert/1")
5534 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-floating-point-convert/2")
5535 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-floating-point-convert/3")
5536 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-floating-point-convert/4")
5537 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-floating-point-convert/5")
5538 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-floating-point-convert/6")
5539 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-floating-point-convert/7")
5540 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-convert/8")
5541 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-floating-point-convert/9")
5542 (check-next-stream-line-equal _test-output-stream " f3 0f 2a/convert-to-float %eax 0x00000001/x32" "F - test-convert-floating-point-convert/10")
5543 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 1/x32" "F - test-convert-floating-point-convert/11")
5544 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-floating-point-convert/12")
5545 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-floating-point-convert/13")
5546 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-floating-point-convert/14")
5547 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-floating-point-convert/15")
5548 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-floating-point-convert/16")
5549 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-floating-point-convert/17")
5550 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-floating-point-convert/18")
5551 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-floating-point-convert/19")
5552
5553 89/<- %esp 5/r32/ebp
5554 5d/pop-to-ebp
5555 c3/return
5556
5557 test-convert-floating-point-convert-2:
5558
5559 55/push-ebp
5560 89/<- %ebp 4/r32/esp
5561
5562 (clear-stream _test-input-stream)
5563 (clear-stream $_test-input-buffered-file->buffer)
5564 (clear-stream _test-output-stream)
5565 (clear-stream $_test-output-buffered-file->buffer)
5566
5567 (write _test-input-stream "fn foo {\n")
5568 (write _test-input-stream " var a/eax: int <- copy 0\n")
5569 (write _test-input-stream " var b/xmm1: float <- convert a\n")
5570 (write _test-input-stream " a <- convert b\n")
5571 (write _test-input-stream "}\n")
5572
5573 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5574 (flush _test-output-buffered-file)
5575 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5581
5582 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-floating-point-convert-2/0")
5583 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-floating-point-convert-2/1")
5584 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-floating-point-convert-2/2")
5585 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-floating-point-convert-2/3")
5586 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-floating-point-convert-2/4")
5587 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-floating-point-convert-2/5")
5588 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-floating-point-convert-2/6")
5589 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-floating-point-convert-2/7")
5590 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-convert-2/8")
5591 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-floating-point-convert-2/9")
5592 (check-next-stream-line-equal _test-output-stream " f3 0f 2a/convert-to-float %eax 0x00000001/x32" "F - test-convert-floating-point-convert-2/10")
5593 (check-next-stream-line-equal _test-output-stream " f3 0f 2d/convert-to-int %xmm1 0x00000000/r32" "F - test-convert-floating-point-convert-2/11")
5594 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 1/x32" "F - test-convert-floating-point-convert-2/12")
5595 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-floating-point-convert-2/13")
5596 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-floating-point-convert-2/14")
5597 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-floating-point-convert-2/15")
5598 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-floating-point-convert-2/16")
5599 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-floating-point-convert-2/17")
5600 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-floating-point-convert-2/18")
5601 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-floating-point-convert-2/19")
5602 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-floating-point-convert-2/20")
5603
5604 89/<- %esp 5/r32/ebp
5605 5d/pop-to-ebp
5606 c3/return
5607
5608 test-convert-floating-point-operation:
5609
5610 55/push-ebp
5611 89/<- %ebp 4/r32/esp
5612
5613 (clear-stream _test-input-stream)
5614 (clear-stream $_test-input-buffered-file->buffer)
5615 (clear-stream _test-output-stream)
5616 (clear-stream $_test-output-buffered-file->buffer)
5617
5618 (write _test-input-stream "fn f {\n")
5619 (write _test-input-stream " var m: float\n")
5620 (write _test-input-stream " var x/xmm1: float <- copy m\n")
5621 (write _test-input-stream " var y/xmm5: float <- copy m\n")
5622 (write _test-input-stream " x <- copy y\n")
5623 (write _test-input-stream " copy-to m, y\n")
5624 (write _test-input-stream " x <- add y\n")
5625 (write _test-input-stream " x <- add m\n")
5626 (write _test-input-stream " x <- subtract y\n")
5627 (write _test-input-stream " x <- subtract m\n")
5628 (write _test-input-stream " x <- multiply y\n")
5629 (write _test-input-stream " x <- multiply m\n")
5630 (write _test-input-stream " x <- divide y\n")
5631 (write _test-input-stream " x <- divide m\n")
5632 (write _test-input-stream " x <- reciprocal y\n")
5633 (write _test-input-stream " x <- reciprocal m\n")
5634 (write _test-input-stream " x <- square-root y\n")
5635 (write _test-input-stream " x <- square-root m\n")
5636 (write _test-input-stream " x <- inverse-square-root y\n")
5637 (write _test-input-stream " x <- inverse-square-root m\n")
5638 (write _test-input-stream " x <- max y\n")
5639 (write _test-input-stream " x <- max m\n")
5640 (write _test-input-stream " x <- min y\n")
5641 (write _test-input-stream " x <- min m\n")
5642 (write _test-input-stream " compare x, y\n")
5643 (write _test-input-stream " compare x, m\n")
5644 (write _test-input-stream "}\n")
5645
5646 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5647 (flush _test-output-buffered-file)
5648 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5654
5655 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-floating-point-operation/0")
5656 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-floating-point-operation/1")
5657 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-floating-point-operation/2")
5658 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-floating-point-operation/3")
5659 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-floating-point-operation/4")
5660 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-floating-point-operation/5")
5661 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-floating-point-operation/6")
5662 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-operation/7")
5663 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-floating-point-operation/8")
5664 (check-next-stream-line-equal _test-output-stream " f3 0f 10/copy *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/9")
5665 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-operation/10")
5666 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 5/x32" "F - test-convert-floating-point-operation/11")
5667 (check-next-stream-line-equal _test-output-stream " f3 0f 10/copy *(ebp+0xfffffffc) 0x00000005/x32" "F - test-convert-floating-point-operation/12")
5668 (check-next-stream-line-equal _test-output-stream " f3 0f 11/copy %xmm1 0x00000005/x32" "F - test-convert-floating-point-operation/13")
5669 (check-next-stream-line-equal _test-output-stream " f3 0f 11/copy *(ebp+0xfffffffc) 0x00000005/x32" "F - test-convert-floating-point-operation/14")
5670 (check-next-stream-line-equal _test-output-stream " f3 0f 58/add %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/15")
5671 (check-next-stream-line-equal _test-output-stream " f3 0f 58/add *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/16")
5672 (check-next-stream-line-equal _test-output-stream " f3 0f 5c/subtract %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/17")
5673 (check-next-stream-line-equal _test-output-stream " f3 0f 5c/subtract *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/18")
5674 (check-next-stream-line-equal _test-output-stream " f3 0f 59/multiply %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/19")
5675 (check-next-stream-line-equal _test-output-stream " f3 0f 59/multiply *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/20")
5676 (check-next-stream-line-equal _test-output-stream " f3 0f 5e/divide %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/21")
5677 (check-next-stream-line-equal _test-output-stream " f3 0f 5e/divide *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/22")
5678 (check-next-stream-line-equal _test-output-stream " f3 0f 53/reciprocal %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/23")
5679 (check-next-stream-line-equal _test-output-stream " f3 0f 53/reciprocal *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/24")
5680 (check-next-stream-line-equal _test-output-stream " f3 0f 51/square-root %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/25")
5681 (check-next-stream-line-equal _test-output-stream " f3 0f 51/square-root *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/26")
5682 (check-next-stream-line-equal _test-output-stream " f3 0f 52/inverse-square-root %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/27")
5683 (check-next-stream-line-equal _test-output-stream " f3 0f 52/inverse-square-root *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/28")
5684 (check-next-stream-line-equal _test-output-stream " f3 0f 5f/max %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/29")
5685 (check-next-stream-line-equal _test-output-stream " f3 0f 5f/max *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/30")
5686 (check-next-stream-line-equal _test-output-stream " f3 0f 5d/min %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/31")
5687 (check-next-stream-line-equal _test-output-stream " f3 0f 5d/min *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/32")
5688 (check-next-stream-line-equal _test-output-stream " 0f 2f/compare %xmm1 0x00000005/x32" "F - test-convert-floating-point-operation/33")
5689 (check-next-stream-line-equal _test-output-stream " 0f 2f/compare *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/34")
5690 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 5/x32" "F - test-convert-floating-point-operation/35")
5691 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-operation/36")
5692 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 1/x32" "F - test-convert-floating-point-operation/37")
5693 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-operation/38")
5694 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-floating-point-operation/39")
5695 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-floating-point-operation/40")
5696 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-floating-point-operation/41")
5697 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-floating-point-operation/42")
5698 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-floating-point-operation/43")
5699 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-floating-point-operation/44")
5700 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-floating-point-operation/45")
5701
5702 89/<- %esp 5/r32/ebp
5703 5d/pop-to-ebp
5704 c3/return
5705
5706 test-convert-floating-point-dereferenced:
5707
5708 55/push-ebp
5709 89/<- %ebp 4/r32/esp
5710
5711 (clear-stream _test-input-stream)
5712 (clear-stream $_test-input-buffered-file->buffer)
5713 (clear-stream _test-output-stream)
5714 (clear-stream $_test-output-buffered-file->buffer)
5715
5716 (write _test-input-stream "fn f {\n")
5717 (write _test-input-stream " var m: float\n")
5718 (write _test-input-stream " var x/xmm1: float <- copy m\n")
5719 (write _test-input-stream " var y/eax: (addr float) <- copy 0\n")
5720 (write _test-input-stream " x <- multiply *y\n")
5721 (write _test-input-stream "}\n")
5722
5723 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5724 (flush _test-output-buffered-file)
5725 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5731
5732 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-floating-point-dereferenced/0")
5733 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-floating-point-dereferenced/1")
5734 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-floating-point-dereferenced/2")
5735 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-floating-point-dereferenced/3")
5736 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-floating-point-dereferenced/4")
5737 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-floating-point-dereferenced/5")
5738 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-floating-point-dereferenced/6")
5739 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-dereferenced/7")
5740 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-floating-point-dereferenced/8")
5741 (check-next-stream-line-equal _test-output-stream " f3 0f 10/copy *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-dereferenced/9")
5742 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-floating-point-dereferenced/10")
5743 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-floating-point-dereferenced/11")
5744 (check-next-stream-line-equal _test-output-stream " f3 0f 59/multiply *eax 0x00000001/x32" "F - test-convert-floating-point-dereferenced/12")
5745 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-floating-point-dereferenced/13")
5746 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 1/x32" "F - test-convert-floating-point-dereferenced/14")
5747 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-dereferenced/15")
5748 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-floating-point-dereferenced/16")
5749 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-floating-point-dereferenced/17")
5750 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-floating-point-dereferenced/18")
5751 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-floating-point-dereferenced/19")
5752 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-floating-point-dereferenced/20")
5753 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-floating-point-dereferenced/21")
5754 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-floating-point-dereferenced/22")
5755
5756 89/<- %esp 5/r32/ebp
5757 5d/pop-to-ebp
5758 c3/return
5759
5760 test-convert-length-of-array:
5761
5762 55/push-ebp
5763 89/<- %ebp 4/r32/esp
5764
5765 (clear-stream _test-input-stream)
5766 (clear-stream $_test-input-buffered-file->buffer)
5767 (clear-stream _test-output-stream)
5768 (clear-stream $_test-output-buffered-file->buffer)
5769
5770 (write _test-input-stream "fn foo a: (addr array int) {\n")
5771 (write _test-input-stream " var b/eax: (addr array int) <- copy a\n")
5772 (write _test-input-stream " var c/eax: int <- length b\n")
5773 (write _test-input-stream "}\n")
5774
5775 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5776 (flush _test-output-buffered-file)
5777 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5783
5784 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array/0")
5785 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array/1")
5786 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array/2")
5787 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array/3")
5788 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array/4")
5789 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array/5")
5790 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array/6")
5791 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-length-of-array/7")
5792 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array/8")
5793 (check-next-stream-line-equal _test-output-stream " c1/shift 5/subop/>> %eax 0x00000002/imm8" "F - test-convert-length-of-array/9")
5794 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array/10")
5795 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array/11")
5796 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array/12")
5797 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array/13")
5798 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array/14")
5799 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array/15")
5800 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array/16")
5801
5802 89/<- %esp 5/r32/ebp
5803 5d/pop-to-ebp
5804 c3/return
5805
5806
5807 test-convert-length-of-array-of-bytes:
5808
5809 55/push-ebp
5810 89/<- %ebp 4/r32/esp
5811
5812 (clear-stream _test-input-stream)
5813 (clear-stream $_test-input-buffered-file->buffer)
5814 (clear-stream _test-output-stream)
5815 (clear-stream $_test-output-buffered-file->buffer)
5816
5817 (write _test-input-stream "fn foo a: (addr array byte) {\n")
5818 (write _test-input-stream " var b/eax: (addr array byte) <- copy a\n")
5819 (write _test-input-stream " var c/eax: int <- length b\n")
5820 (write _test-input-stream "}\n")
5821
5822 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5823 (flush _test-output-buffered-file)
5824 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5830
5831 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-bytes/0")
5832 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-bytes/1")
5833 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-bytes/2")
5834 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-bytes/3")
5835 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-bytes/4")
5836 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-bytes/5")
5837 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-bytes/6")
5838 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-length-of-array-of-bytes/7")
5839 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-bytes/8")
5840 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-bytes/9")
5841 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-bytes/10")
5842 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-bytes/11")
5843 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-bytes/12")
5844 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-bytes/13")
5845 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-bytes/14")
5846 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-bytes/15")
5847
5848 89/<- %esp 5/r32/ebp
5849 5d/pop-to-ebp
5850 c3/return
5851
5852 test-convert-length-of-array-on-stack:
5853
5854 55/push-ebp
5855 89/<- %ebp 4/r32/esp
5856
5857 (clear-stream _test-input-stream)
5858 (clear-stream $_test-input-buffered-file->buffer)
5859 (clear-stream _test-output-stream)
5860 (clear-stream $_test-output-buffered-file->buffer)
5861
5862 (write _test-input-stream "fn foo {\n")
5863 (write _test-input-stream " var a: (array int 3)\n")
5864 (write _test-input-stream " var b/eax: int <- length a\n")
5865 (write _test-input-stream "}\n")
5866
5867 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5868 (flush _test-output-buffered-file)
5869 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5875
5876 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-on-stack/0")
5877 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-on-stack/1")
5878 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-on-stack/2")
5879 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-on-stack/3")
5880 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-on-stack/4")
5881 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-on-stack/5")
5882
5883 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-length-of-array-on-stack/6")
5884 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-length-of-array-on-stack/7")
5885 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-on-stack/8")
5886 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0xfffffff0) 0x00000000/r32" "F - test-convert-length-of-array-on-stack/9")
5887 (check-next-stream-line-equal _test-output-stream " c1/shift 5/subop/>> %eax 0x00000002/imm8" "F - test-convert-length-of-array-on-stack/10")
5888 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-on-stack/11")
5889 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-length-of-array-on-stack/12")
5890 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-on-stack/13")
5891 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-on-stack/14")
5892 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-on-stack/15")
5893 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-on-stack/16")
5894 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-on-stack/17")
5895 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-on-stack/18")
5896
5897 89/<- %esp 5/r32/ebp
5898 5d/pop-to-ebp
5899 c3/return
5900
5901 test-reg-var-def-with-read-of-same-register:
5902
5903 55/push-ebp
5904 89/<- %ebp 4/r32/esp
5905
5906 (clear-stream _test-input-stream)
5907 (clear-stream $_test-input-buffered-file->buffer)
5908 (clear-stream _test-output-stream)
5909 (clear-stream $_test-output-buffered-file->buffer)
5910 (clear-stream _test-error-stream)
5911 (clear-stream $_test-error-buffered-file->buffer)
5912
5913 68/push 0/imm32
5914 68/push 0/imm32
5915 89/<- %edx 4/r32/esp
5916 (tailor-exit-descriptor %edx 0x10)
5917
5918 (write _test-input-stream "fn foo {\n")
5919 (write _test-input-stream " var x/eax: int <- copy 3\n")
5920 (write _test-input-stream " var y/eax: int <- add x\n")
5921 (write _test-input-stream "}\n")
5922
5923 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
5924
5925
5926 89/<- %edx 4/r32/esp
5927 (flush _test-output-buffered-file)
5928 (flush _test-error-buffered-file)
5929 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5935 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
5941 (check-stream-equal _test-error-stream "" "F - test-reg-var-def-with-read-of-same-register: error stream should be empty")
5942
5943 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-reg-var-def-with-read-of-same-register/0")
5944 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-reg-var-def-with-read-of-same-register/1")
5945 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-reg-var-def-with-read-of-same-register/2")
5946 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-reg-var-def-with-read-of-same-register/3")
5947 (check-next-stream-line-equal _test-output-stream " {" "F - test-reg-var-def-with-read-of-same-register/4")
5948 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-reg-var-def-with-read-of-same-register/5")
5949 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-reg-var-def-with-read-of-same-register/6")
5950 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-reg-var-def-with-read-of-same-register/7")
5951 (check-next-stream-line-equal _test-output-stream " 01/add-to %eax 0x00000000/r32" "F - test-reg-var-def-with-read-of-same-register/8")
5952 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-reg-var-def-with-read-of-same-register/9")
5953 (check-next-stream-line-equal _test-output-stream " }" "F - test-reg-var-def-with-read-of-same-register/10")
5954 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-reg-var-def-with-read-of-same-register/11")
5955 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-reg-var-def-with-read-of-same-register/12")
5956 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-reg-var-def-with-read-of-same-register/13")
5957 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-reg-var-def-with-read-of-same-register/14")
5958 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-reg-var-def-with-read-of-same-register/15")
5959
5960 81 0/subop/add %esp 8/imm32
5961
5962 5d/pop-to-ebp
5963 c3/return
5964
5965 test-convert-index-into-array:
5966
5967 55/push-ebp
5968 89/<- %ebp 4/r32/esp
5969
5970 (clear-stream _test-input-stream)
5971 (clear-stream $_test-input-buffered-file->buffer)
5972 (clear-stream _test-output-stream)
5973 (clear-stream $_test-output-buffered-file->buffer)
5974
5975 (write _test-input-stream "fn foo {\n")
5976 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n")
5977 (write _test-input-stream " var idx/ecx: int <- copy 3\n")
5978 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n")
5979 (write _test-input-stream "}\n")
5980
5981 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
5982 (flush _test-output-buffered-file)
5983 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
5989
5990 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array/0")
5991 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array/1")
5992 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array/2")
5993 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array/3")
5994 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array/4")
5995 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array/5")
5996 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array/6")
5997 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array/7")
5998 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array/8")
5999 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array/9")
6000 (check-next-stream-line-equal _test-output-stream " (__check-mu-array-bounds %ecx 0x00000004 *eax \"foo\" \"arr\")" "F - test-convert-index-into-array/10")
6001 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000002 + 4) 0x00000000/r32" "F - test-convert-index-into-array/11")
6002 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array/12")
6003 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array/13")
6004 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array/14")
6005 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array/15")
6006 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array/16")
6007 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array/17")
6008 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array/18")
6009 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array/19")
6010
6011 89/<- %esp 5/r32/ebp
6012 5d/pop-to-ebp
6013 c3/return
6014
6015 test-convert-index-into-array-of-bytes:
6016
6017 55/push-ebp
6018 89/<- %ebp 4/r32/esp
6019
6020 (clear-stream _test-input-stream)
6021 (clear-stream $_test-input-buffered-file->buffer)
6022 (clear-stream _test-output-stream)
6023 (clear-stream $_test-output-buffered-file->buffer)
6024
6025 (write _test-input-stream "fn foo {\n")
6026 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n")
6027 (write _test-input-stream " var idx/ecx: int <- copy 3\n")
6028 (write _test-input-stream " var x/eax: (addr byte) <- index arr, idx\n")
6029 (write _test-input-stream "}\n")
6030
6031 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6032 (flush _test-output-buffered-file)
6033 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6039
6040 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes/0")
6041 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes/1")
6042 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes/2")
6043 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes/3")
6044 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes/4")
6045 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes/5")
6046 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes/6")
6047 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes/7")
6048 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes/8")
6049 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-of-bytes/9")
6050 (check-next-stream-line-equal _test-output-stream " (__check-mu-array-bounds %ecx 0x00000001 *eax \"foo\" \"arr\")" "F - test-convert-index-into-array-of-bytes/10")
6051 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000000 + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes/11")
6052 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes/12")
6053 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes/13")
6054 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes/14")
6055 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes/15")
6056 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes/16")
6057 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes/17")
6058 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes/18")
6059 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes/19")
6060
6061 89/<- %esp 5/r32/ebp
6062 5d/pop-to-ebp
6063 c3/return
6064
6065 test-convert-index-into-array-with-literal:
6066
6067 55/push-ebp
6068 89/<- %ebp 4/r32/esp
6069
6070 (clear-stream _test-input-stream)
6071 (clear-stream $_test-input-buffered-file->buffer)
6072 (clear-stream _test-output-stream)
6073 (clear-stream $_test-output-buffered-file->buffer)
6074
6075 (write _test-input-stream "fn foo {\n")
6076 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n")
6077 (write _test-input-stream " var x/eax: (addr int) <- index arr, 2\n")
6078 (write _test-input-stream "}\n")
6079
6080 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6081 (flush _test-output-buffered-file)
6082 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6088
6089 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-with-literal/0")
6090 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-with-literal/1")
6091 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-with-literal/2")
6092 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-with-literal/3")
6093 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-with-literal/4")
6094 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-with-literal/5")
6095 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-with-literal/6")
6096 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-with-literal/7")
6097 (check-next-stream-line-equal _test-output-stream " (__check-mu-array-bounds 2 0x00000004 *eax \"foo\" \"arr\")" "F - test-convert-index-into-array-with-literal/8")
6098
6099 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x0000000c) 0x00000000/r32" "F - test-convert-index-into-array-with-literal/9")
6100 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-with-literal/10")
6101 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-with-literal/11")
6102 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-with-literal/12")
6103 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-with-literal/13")
6104 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-with-literal/14")
6105 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-with-literal/15")
6106 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-with-literal/16")
6107
6108 89/<- %esp 5/r32/ebp
6109 5d/pop-to-ebp
6110 c3/return
6111
6112 test-convert-index-into-array-of-bytes-with-literal:
6113
6114 55/push-ebp
6115 89/<- %ebp 4/r32/esp
6116
6117 (clear-stream _test-input-stream)
6118 (clear-stream $_test-input-buffered-file->buffer)
6119 (clear-stream _test-output-stream)
6120 (clear-stream $_test-output-buffered-file->buffer)
6121
6122 (write _test-input-stream "fn foo {\n")
6123 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n")
6124 (write _test-input-stream " var x/eax: (addr byte) <- index arr, 2\n")
6125 (write _test-input-stream "}\n")
6126
6127 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6128 (flush _test-output-buffered-file)
6129 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6135
6136 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-with-literal/0")
6137 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-with-literal/1")
6138 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-with-literal/2")
6139 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-with-literal/3")
6140 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-with-literal/4")
6141 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-with-literal/5")
6142 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-with-literal/6")
6143 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-with-literal/7")
6144 (check-next-stream-line-equal _test-output-stream " (__check-mu-array-bounds 2 0x00000001 *eax \"foo\" \"arr\")" "F - test-convert-index-into-array-of-bytes-with-literal/8")
6145
6146 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000006) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-with-literal/8")
6147 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-with-literal/9")
6148 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-with-literal/10")
6149 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-with-literal/11")
6150 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-with-literal/12")
6151 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-with-literal/13")
6152 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-with-literal/14")
6153 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-with-literal/15")
6154
6155 89/<- %esp 5/r32/ebp
6156 5d/pop-to-ebp
6157 c3/return
6158
6159 test-convert-index-into-array-on-stack:
6160
6161 55/push-ebp
6162 89/<- %ebp 4/r32/esp
6163
6164 (clear-stream _test-input-stream)
6165 (clear-stream $_test-input-buffered-file->buffer)
6166 (clear-stream _test-output-stream)
6167 (clear-stream $_test-output-buffered-file->buffer)
6168
6169 (write _test-input-stream "fn foo {\n")
6170 (write _test-input-stream " var arr: (array int 3)\n")
6171 (write _test-input-stream " var idx/eax: int <- copy 2\n")
6172 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n")
6173 (write _test-input-stream "}\n")
6174
6175 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6176 (flush _test-output-buffered-file)
6177 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6183
6184 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-on-stack/0")
6185 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-on-stack/1")
6186 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-on-stack/2")
6187 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-on-stack/3")
6188 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-on-stack/4")
6189 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-on-stack/5")
6190
6191 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-index-into-array-on-stack/6")
6192 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-index-into-array-on-stack/7")
6193
6194 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-on-stack/8")
6195 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 2/imm32" "F - test-convert-index-into-array-on-stack/9")
6196 (check-next-stream-line-equal _test-output-stream " (__check-mu-array-bounds %eax 0x00000004 *(ebp+0xfffffff0) \"foo\" \"arr\")" "F - test-convert-index-into-array-on-stack/10")
6197
6198 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + eax<<0x00000002 + 0xfffffff4) 0x00000000/r32" "F - test-convert-index-into-array-on-stack/11")
6199
6200 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-on-stack/12")
6201
6202 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-index-into-array-on-stack/13")
6203
6204 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-on-stack/14")
6205 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-on-stack/15")
6206 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-on-stack/16")
6207 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-on-stack/17")
6208 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-on-stack/18")
6209 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-on-stack/19")
6210
6211 89/<- %esp 5/r32/ebp
6212 5d/pop-to-ebp
6213 c3/return
6214
6215 test-convert-index-into-array-on-stack-with-literal:
6216
6217 55/push-ebp
6218 89/<- %ebp 4/r32/esp
6219
6220 (clear-stream _test-input-stream)
6221 (clear-stream $_test-input-buffered-file->buffer)
6222 (clear-stream _test-output-stream)
6223 (clear-stream $_test-output-buffered-file->buffer)
6224
6225 (write _test-input-stream "fn foo {\n")
6226 (write _test-input-stream " var arr: (array int 3)\n")
6227 (write _test-input-stream " var x/eax: (addr int) <- index arr, 2\n")
6228 (write _test-input-stream "}\n")
6229
6230 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6231 (flush _test-output-buffered-file)
6232 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6238
6239 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-on-stack-with-literal/0")
6240 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-on-stack-with-literal/1")
6241 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-on-stack-with-literal/2")
6242 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-on-stack-with-literal/3")
6243 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-on-stack-with-literal/4")
6244 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-on-stack-with-literal/5")
6245
6246 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-index-into-array-on-stack-with-literal/6")
6247 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-index-into-array-on-stack-with-literal/7")
6248
6249 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-on-stack-with-literal/8")
6250 (check-next-stream-line-equal _test-output-stream " (__check-mu-array-bounds 2 0x00000004 *(ebp+0xfffffff0) \"foo\" \"arr\")" "F - test-convert-index-into-array-on-stack-with-literal/9")
6251
6252 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + 0xfffffffc) 0x00000000/r32" "F - test-convert-index-into-array-on-stack-with-literal/10")
6253
6254 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-on-stack-with-literal/11")
6255
6256 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-index-into-array-on-stack-with-literal/12")
6257
6258 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-on-stack-with-literal/13")
6259 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-on-stack-with-literal/14")
6260 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-on-stack-with-literal/15")
6261 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-on-stack-with-literal/16")
6262 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-on-stack-with-literal/17")
6263 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-on-stack-with-literal/18")
6264
6265 89/<- %esp 5/r32/ebp
6266 5d/pop-to-ebp
6267 c3/return
6268
6269 test-convert-index-into-array-of-bytes-on-stack-with-literal:
6270
6271 55/push-ebp
6272 89/<- %ebp 4/r32/esp
6273
6274 (clear-stream _test-input-stream)
6275 (clear-stream $_test-input-buffered-file->buffer)
6276 (clear-stream _test-output-stream)
6277 (clear-stream $_test-output-buffered-file->buffer)
6278
6279 (write _test-input-stream "fn foo {\n")
6280 (write _test-input-stream " var arr: (array byte 3)\n")
6281 (write _test-input-stream " var x/eax: (addr byte) <- index arr, 2\n")
6282 (write _test-input-stream "}\n")
6283
6284 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6285 (flush _test-output-buffered-file)
6286 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6292
6293 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/0")
6294 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/1")
6295 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/2")
6296 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/3")
6297 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/4")
6298 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/5")
6299
6300 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x00000003)" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/6")
6301 (check-next-stream-line-equal _test-output-stream " 68/push 0x00000003/imm32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/7")
6302
6303 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/8")
6304 (check-next-stream-line-equal _test-output-stream " (__check-mu-array-bounds 2 0x00000001 *(ebp+0xfffffff9) \"foo\" \"arr\")" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/9")
6305
6306 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + 0xffffffff) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/10")
6307
6308 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/11")
6309
6310 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000007/imm32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/12")
6311
6312 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/13")
6313 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/14")
6314 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/15")
6315 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/16")
6316 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/17")
6317 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/18")
6318
6319 89/<- %esp 5/r32/ebp
6320 5d/pop-to-ebp
6321 c3/return
6322
6323 test-convert-index-into-array-using-offset:
6324
6325 55/push-ebp
6326 89/<- %ebp 4/r32/esp
6327
6328 (clear-stream _test-input-stream)
6329 (clear-stream $_test-input-buffered-file->buffer)
6330 (clear-stream _test-output-stream)
6331 (clear-stream $_test-output-buffered-file->buffer)
6332
6333 (write _test-input-stream "fn foo {\n")
6334 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n")
6335 (write _test-input-stream " var idx/ecx: int <- copy 3\n")
6336 (write _test-input-stream " var off/ecx: (offset int) <- compute-offset arr, idx\n")
6337 (write _test-input-stream " var x/eax: (addr int) <- index arr, off\n")
6338 (write _test-input-stream "}\n")
6339
6340 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6341 (flush _test-output-buffered-file)
6342 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6348
6349 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-using-offset/0")
6350 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-using-offset/1")
6351 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-using-offset/2")
6352 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-using-offset/3")
6353 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-using-offset/4")
6354 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-using-offset/5")
6355 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-using-offset/6")
6356 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-using-offset/7")
6357 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-using-offset/8")
6358 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-using-offset/9")
6359 (check-next-stream-line-equal _test-output-stream " 69/multiply %ecx 0x00000004/imm32 0x00000001/r32" "F - test-convert-index-into-array-using-offset/10")
6360 (check-next-stream-line-equal _test-output-stream " (__check-mu-array-bounds %ecx 1 *eax \"foo\" \"arr\")" "F - test-convert-index-into-array-using-offset/11")
6361 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-using-offset/12")
6362 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-using-offset/13")
6363 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-using-offset/14")
6364 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-using-offset/15")
6365 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-using-offset/16")
6366 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-using-offset/17")
6367 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-using-offset/18")
6368 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-using-offset/19")
6369 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-using-offset/20")
6370
6371 89/<- %esp 5/r32/ebp
6372 5d/pop-to-ebp
6373 c3/return
6374
6375 test-convert-index-into-array-of-bytes-using-offset:
6376
6377 55/push-ebp
6378 89/<- %ebp 4/r32/esp
6379
6380 (clear-stream _test-input-stream)
6381 (clear-stream $_test-input-buffered-file->buffer)
6382 (clear-stream _test-output-stream)
6383 (clear-stream $_test-output-buffered-file->buffer)
6384
6385 (write _test-input-stream "fn foo {\n")
6386 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n")
6387 (write _test-input-stream " var idx/ecx: int <- copy 3\n")
6388 (write _test-input-stream " var off/ecx: (offset byte) <- compute-offset arr, idx\n")
6389 (write _test-input-stream " var x/eax: (addr byte) <- index arr, off\n")
6390 (write _test-input-stream "}\n")
6391
6392 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6393 (flush _test-output-buffered-file)
6394 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6400
6401 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-using-offset/0")
6402 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-using-offset/1")
6403 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-using-offset/2")
6404 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-using-offset/3")
6405 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-using-offset/4")
6406 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-using-offset/5")
6407 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-using-offset/6")
6408 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset/7")
6409 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes-using-offset/8")
6410 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-of-bytes-using-offset/9")
6411 (check-next-stream-line-equal _test-output-stream " 69/multiply %ecx 0x00000001/imm32 0x00000001/r32" "F - test-convert-index-into-array-of-bytes-using-offset/10")
6412 (check-next-stream-line-equal _test-output-stream " (__check-mu-array-bounds %ecx 1 *eax \"foo\" \"arr\")" "F - test-convert-index-into-array-of-bytes-using-offset/11")
6413 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-using-offset/12")
6414 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes-using-offset/13")
6415 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-using-offset/14")
6416 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-using-offset/15")
6417 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-using-offset/16")
6418 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-using-offset/17")
6419 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-using-offset/18")
6420 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-using-offset/19")
6421 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-using-offset/20")
6422
6423 89/<- %esp 5/r32/ebp
6424 5d/pop-to-ebp
6425 c3/return
6426
6427 test-convert-index-into-array-using-offset-on-stack:
6428
6429 55/push-ebp
6430 89/<- %ebp 4/r32/esp
6431
6432 (clear-stream _test-input-stream)
6433 (clear-stream $_test-input-buffered-file->buffer)
6434 (clear-stream _test-output-stream)
6435 (clear-stream $_test-output-buffered-file->buffer)
6436
6437 (write _test-input-stream "fn foo {\n")
6438 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n")
6439 (write _test-input-stream " var idx: int\n")
6440 (write _test-input-stream " var off/ecx: (offset int) <- compute-offset arr, idx\n")
6441 (write _test-input-stream " var x/eax: (addr int) <- index arr, off\n")
6442 (write _test-input-stream "}\n")
6443
6444 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6445 (flush _test-output-buffered-file)
6446 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6452
6453 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-using-offset-on-stack/0")
6454 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-using-offset-on-stack/1")
6455 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-using-offset-on-stack/2")
6456 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-using-offset-on-stack/3")
6457 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-using-offset-on-stack/4")
6458 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-using-offset-on-stack/5")
6459 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-using-offset-on-stack/6")
6460 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-using-offset-on-stack/7")
6461 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-index-into-array-using-offset-on-stack/8")
6462 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-using-offset-on-stack/9")
6463 (check-next-stream-line-equal _test-output-stream " 69/multiply *(ebp+0xfffffff8) 0x00000004/imm32 0x00000001/r32" "F - test-convert-index-into-array-using-offset-on-stack/10")
6464 (check-next-stream-line-equal _test-output-stream " (__check-mu-array-bounds %ecx 1 *eax \"foo\" \"arr\")" "F - test-convert-index-into-array-using-offset-on-stack/11")
6465 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-using-offset-on-stack/12")
6466 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-using-offset-on-stack/13")
6467 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-index-into-array-using-offset-on-stack/14")
6468 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-using-offset-on-stack/15")
6469 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-using-offset-on-stack/16")
6470 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-using-offset-on-stack/17")
6471 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-using-offset-on-stack/18")
6472 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-using-offset-on-stack/19")
6473 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-using-offset-on-stack/20")
6474 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-using-offset-on-stack/21")
6475
6476 89/<- %esp 5/r32/ebp
6477 5d/pop-to-ebp
6478 c3/return
6479
6480 test-convert-index-into-array-of-bytes-using-offset-on-stack:
6481
6482 55/push-ebp
6483 89/<- %ebp 4/r32/esp
6484
6485 (clear-stream _test-input-stream)
6486 (clear-stream $_test-input-buffered-file->buffer)
6487 (clear-stream _test-output-stream)
6488 (clear-stream $_test-output-buffered-file->buffer)
6489
6490 (write _test-input-stream "fn foo {\n")
6491 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n")
6492 (write _test-input-stream " var idx: int\n")
6493 (write _test-input-stream " var off/ecx: (offset byte) <- compute-offset arr, idx\n")
6494 (write _test-input-stream " var x/eax: (addr byte) <- index arr, off\n")
6495 (write _test-input-stream "}\n")
6496
6497 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6498 (flush _test-output-buffered-file)
6499 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6505
6506 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/0")
6507 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/1")
6508 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/2")
6509 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/3")
6510 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/4")
6511 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/5")
6512 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/6")
6513 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/7")
6514 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/8")
6515 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/9")
6516 (check-next-stream-line-equal _test-output-stream " 69/multiply *(ebp+0xfffffff8) 0x00000001/imm32 0x00000001/r32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/10")
6517 (check-next-stream-line-equal _test-output-stream " (__check-mu-array-bounds %ecx 1 *eax \"foo\" \"arr\")" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/11")
6518 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/12")
6519 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/13")
6520 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/14")
6521 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/15")
6522 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/16")
6523 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/17")
6524 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/18")
6525 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/19")
6526 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/20")
6527 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/21")
6528
6529 89/<- %esp 5/r32/ebp
6530 5d/pop-to-ebp
6531 c3/return
6532
6533 test-convert-function-and-type-definition:
6534
6535 55/push-ebp
6536 89/<- %ebp 4/r32/esp
6537
6538 (clear-stream _test-input-stream)
6539 (clear-stream $_test-input-buffered-file->buffer)
6540 (clear-stream _test-output-stream)
6541 (clear-stream $_test-output-buffered-file->buffer)
6542
6543 (write _test-input-stream "fn foo a: (addr t) {\n")
6544 (write _test-input-stream " var _a/eax: (addr t) <- copy a\n")
6545 (write _test-input-stream " var b/ecx: (addr int) <- get _a, x\n")
6546 (write _test-input-stream " var c/ecx: (addr int) <- get _a, y\n")
6547 (write _test-input-stream "}\n")
6548 (write _test-input-stream "type t {\n")
6549 (write _test-input-stream " x: int\n")
6550 (write _test-input-stream " y: int\n")
6551 (write _test-input-stream "}\n")
6552
6553 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6554 (flush _test-output-buffered-file)
6555 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6561
6562 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-and-type-definition/0")
6563 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-and-type-definition/1")
6564 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-and-type-definition/2")
6565 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-and-type-definition/3")
6566 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-and-type-definition/4")
6567 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-and-type-definition/5")
6568 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-and-type-definition/6")
6569 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-function-and-type-definition/7")
6570 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-and-type-definition/8")
6571 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000000) 0x00000001/r32" "F - test-convert-function-and-type-definition/9")
6572 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000004) 0x00000001/r32" "F - test-convert-function-and-type-definition/11")
6573 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-and-type-definition/13")
6574 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-and-type-definition/14")
6575 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-and-type-definition/15")
6576 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-and-type-definition/16")
6577 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-and-type-definition/17")
6578 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-and-type-definition/18")
6579 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-and-type-definition/19")
6580 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-and-type-definition/20")
6581
6582 89/<- %esp 5/r32/ebp
6583 5d/pop-to-ebp
6584 c3/return
6585
6586 test-type-definition-with-array:
6587
6588 55/push-ebp
6589 89/<- %ebp 4/r32/esp
6590
6591 (clear-stream _test-input-stream)
6592 (clear-stream $_test-input-buffered-file->buffer)
6593 (clear-stream _test-output-stream)
6594 (clear-stream $_test-output-buffered-file->buffer)
6595 (clear-stream _test-error-stream)
6596 (clear-stream $_test-error-buffered-file->buffer)
6597
6598 68/push 0/imm32
6599 68/push 0/imm32
6600 89/<- %edx 4/r32/esp
6601 (tailor-exit-descriptor %edx 0x10)
6602
6603 (write _test-input-stream "type t {\n")
6604 (write _test-input-stream " a: (array int 3)\n")
6605 (write _test-input-stream "}\n")
6606
6607 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
6608
6609
6610 89/<- %edx 4/r32/esp
6611 (flush _test-output-buffered-file)
6612 (flush _test-error-buffered-file)
6613 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
6619
6620 (check-stream-equal _test-output-stream "" "F - test-type-definition-with-array: output should be empty")
6621 (check-next-stream-line-equal _test-error-stream "type t: 'array' elements not allowed for now" "F - test-type-definition-with-array: error message")
6622
6623 (check-ints-equal *(edx+4) 2 "F - test-type-definition-with-array: exit status")
6624
6625 81 0/subop/add %esp 8/imm32
6626
6627 5d/pop-to-ebp
6628 c3/return
6629
6630 test-type-definition-with-addr:
6631
6632 55/push-ebp
6633 89/<- %ebp 4/r32/esp
6634
6635 (clear-stream _test-input-stream)
6636 (clear-stream $_test-input-buffered-file->buffer)
6637 (clear-stream _test-output-stream)
6638 (clear-stream $_test-output-buffered-file->buffer)
6639 (clear-stream _test-error-stream)
6640 (clear-stream $_test-error-buffered-file->buffer)
6641
6642 68/push 0/imm32
6643 68/push 0/imm32
6644 89/<- %edx 4/r32/esp
6645 (tailor-exit-descriptor %edx 0x10)
6646
6647 (write _test-input-stream "type t {\n")
6648 (write _test-input-stream " a: (addr int)\n")
6649 (write _test-input-stream "}\n")
6650
6651 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
6652
6653
6654 89/<- %edx 4/r32/esp
6655 (flush _test-output-buffered-file)
6656 (flush _test-error-buffered-file)
6657 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
6663
6664 (check-stream-equal _test-output-stream "" "F - test-type-definition-with-addr: output should be empty")
6665 (check-next-stream-line-equal _test-error-stream "type t: 'addr' elements not allowed" "F - test-type-definition-with-addr: error message")
6666
6667 (check-ints-equal *(edx+4) 2 "F - test-type-definition-with-addr: exit status")
6668
6669 81 0/subop/add %esp 8/imm32
6670
6671 5d/pop-to-ebp
6672 c3/return
6673
6674 test-convert-function-with-local-var-with-user-defined-type:
6675
6676 55/push-ebp
6677 89/<- %ebp 4/r32/esp
6678
6679 (clear-stream _test-input-stream)
6680 (clear-stream $_test-input-buffered-file->buffer)
6681 (clear-stream _test-output-stream)
6682 (clear-stream $_test-output-buffered-file->buffer)
6683
6684 (write _test-input-stream "fn foo {\n")
6685 (write _test-input-stream " var a: t\n")
6686 (write _test-input-stream "}\n")
6687 (write _test-input-stream "type t {\n")
6688 (write _test-input-stream " x: int\n")
6689 (write _test-input-stream " y: int\n")
6690 (write _test-input-stream "}\n")
6691
6692 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6693 (flush _test-output-buffered-file)
6694 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6700
6701 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-user-defined-type/0")
6702 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-user-defined-type/1")
6703 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-with-user-defined-type/2")
6704 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-with-user-defined-type/3")
6705 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-with-user-defined-type/4")
6706 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-with-user-defined-type/5")
6707 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/6")
6708 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/7")
6709 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/8")
6710 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-with-user-defined-type/9")
6711 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-with-user-defined-type/10")
6712 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-with-user-defined-type/11")
6713 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-with-user-defined-type/12")
6714 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-with-user-defined-type/13")
6715 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-with-user-defined-type/14")
6716
6717 89/<- %esp 5/r32/ebp
6718 5d/pop-to-ebp
6719 c3/return
6720
6721 test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type:
6722
6723 55/push-ebp
6724 89/<- %ebp 4/r32/esp
6725
6726 (clear-stream _test-input-stream)
6727 (clear-stream $_test-input-buffered-file->buffer)
6728 (clear-stream _test-output-stream)
6729 (clear-stream $_test-output-buffered-file->buffer)
6730
6731 (write _test-input-stream "fn foo {\n")
6732 (write _test-input-stream " var a: t\n")
6733 (write _test-input-stream "}\n")
6734 (write _test-input-stream "type t {\n")
6735 (write _test-input-stream " x: s\n")
6736 (write _test-input-stream "}\n")
6737 (write _test-input-stream "type s {\n")
6738 (write _test-input-stream " z: int\n")
6739 (write _test-input-stream "}\n")
6740
6741 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6742 (flush _test-output-buffered-file)
6743 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6749
6750 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/0")
6751 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/1")
6752 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/2")
6753 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/3")
6754 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/4")
6755 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/5")
6756 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/7")
6757 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/8")
6758 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/9")
6759 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/10")
6760 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/11")
6761 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/12")
6762 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/13")
6763 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/14")
6764
6765 89/<- %esp 5/r32/ebp
6766 5d/pop-to-ebp
6767 c3/return
6768
6769 test-convert-function-call-with-arg-of-user-defined-type:
6770
6771 55/push-ebp
6772 89/<- %ebp 4/r32/esp
6773
6774 (clear-stream _test-input-stream)
6775 (clear-stream $_test-input-buffered-file->buffer)
6776 (clear-stream _test-output-stream)
6777 (clear-stream $_test-output-buffered-file->buffer)
6778
6779 (write _test-input-stream "fn f {\n")
6780 (write _test-input-stream " var a: t\n")
6781 (write _test-input-stream " foo a\n")
6782 (write _test-input-stream "}\n")
6783 (write _test-input-stream "fn foo x: t {\n")
6784 (write _test-input-stream "}\n")
6785 (write _test-input-stream "type t {\n")
6786 (write _test-input-stream " x: int\n")
6787 (write _test-input-stream " y: int\n")
6788 (write _test-input-stream "}\n")
6789
6790 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6791 (flush _test-output-buffered-file)
6792 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6798
6799 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type/0")
6800 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/1")
6801 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/2")
6802 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/3")
6803 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type/4")
6804 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type/5")
6805
6806 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/6")
6807 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/7")
6808
6809 (check-next-stream-line-equal _test-output-stream " (foo *(ebp+0xfffffff8) *(ebp+0xfffffffc))" "F - test-convert-function-call-with-arg-of-user-defined-type/8")
6810
6811 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/9")
6812 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type/10")
6813 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type/11")
6814 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/12")
6815 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/13")
6816 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/14")
6817 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/15")
6818 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type/16")
6819 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/17")
6820 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/18")
6821 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/19")
6822 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/20")
6823 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/21")
6824 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/22")
6825 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/23")
6826
6827 89/<- %esp 5/r32/ebp
6828 5d/pop-to-ebp
6829 c3/return
6830
6831 test-convert-function-call-with-arg-of-user-defined-type-register-indirect:
6832
6833 55/push-ebp
6834 89/<- %ebp 4/r32/esp
6835
6836 (clear-stream _test-input-stream)
6837 (clear-stream $_test-input-buffered-file->buffer)
6838 (clear-stream _test-output-stream)
6839 (clear-stream $_test-output-buffered-file->buffer)
6840
6841 (write _test-input-stream "fn f {\n")
6842 (write _test-input-stream " var a/eax: (addr t) <- copy 0\n")
6843 (write _test-input-stream " foo *a\n")
6844 (write _test-input-stream "}\n")
6845 (write _test-input-stream "fn foo x: t {\n")
6846 (write _test-input-stream "}\n")
6847 (write _test-input-stream "type t {\n")
6848 (write _test-input-stream " x: int\n")
6849 (write _test-input-stream " y: int\n")
6850 (write _test-input-stream "}\n")
6851
6852 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6853 (flush _test-output-buffered-file)
6854 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6860
6861 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type/0")
6862 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/1")
6863 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/2")
6864 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/3")
6865 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type/4")
6866 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type/5")
6867
6868 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-arg-of-user-defined-type/6")
6869 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/7")
6870
6871 (check-next-stream-line-equal _test-output-stream " (foo *(eax+0x00000000) *(eax+0x00000004))" "F - test-convert-function-call-with-arg-of-user-defined-type/8")
6872
6873 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-call-with-arg-of-user-defined-type/9")
6874 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type/10")
6875 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type/11")
6876 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/12")
6877 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/13")
6878 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/14")
6879 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/15")
6880 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type/16")
6881 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/17")
6882 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/18")
6883 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/19")
6884 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/20")
6885 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/21")
6886 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/22")
6887 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/23")
6888
6889 89/<- %esp 5/r32/ebp
6890 5d/pop-to-ebp
6891 c3/return
6892
6893
6894
6895 test-convert-function-call-with-arg-of-user-defined-type-by-reference:
6896
6897 55/push-ebp
6898 89/<- %ebp 4/r32/esp
6899
6900 (clear-stream _test-input-stream)
6901 (clear-stream $_test-input-buffered-file->buffer)
6902 (clear-stream _test-output-stream)
6903 (clear-stream $_test-output-buffered-file->buffer)
6904
6905 (write _test-input-stream "fn f {\n")
6906 (write _test-input-stream " var a: t\n")
6907 (write _test-input-stream " var b/eax: (addr t) <- address a\n")
6908 (write _test-input-stream " foo b\n")
6909 (write _test-input-stream "}\n")
6910 (write _test-input-stream "fn foo x: (addr t) {\n")
6911 (write _test-input-stream " var x/ecx: (addr t) <- copy x\n")
6912 (write _test-input-stream "}\n")
6913 (write _test-input-stream "type t {\n")
6914 (write _test-input-stream " x: int\n")
6915 (write _test-input-stream " y: int\n")
6916 (write _test-input-stream "}\n")
6917
6918 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6919 (flush _test-output-buffered-file)
6920 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6926
6927 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/0")
6928 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/1")
6929 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/2")
6930 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/3")
6931 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/4")
6932 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/5")
6933
6934 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/6")
6935 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/7")
6936
6937 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/8")
6938 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffff8) 0x00000000/r32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/9")
6939
6940 (check-next-stream-line-equal _test-output-stream " (foo %eax)" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/10")
6941
6942 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/11")
6943 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/12")
6944 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/13")
6945 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/14")
6946 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/15")
6947 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/16")
6948 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/17")
6949 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/18")
6950 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/19")
6951 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/20")
6952 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/21")
6953 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/22")
6954 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/23")
6955 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/24")
6956 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/25")
6957 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000001/r32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/26")
6958 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/27")
6959 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/28")
6960 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/29")
6961 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/30")
6962 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/31")
6963 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/32")
6964 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/33")
6965
6966 89/<- %esp 5/r32/ebp
6967 5d/pop-to-ebp
6968 c3/return
6969
6970 test-convert-get-on-local-variable:
6971
6972 55/push-ebp
6973 89/<- %ebp 4/r32/esp
6974
6975 (clear-stream _test-input-stream)
6976 (clear-stream $_test-input-buffered-file->buffer)
6977 (clear-stream _test-output-stream)
6978 (clear-stream $_test-output-buffered-file->buffer)
6979
6980 (write _test-input-stream "fn foo {\n")
6981 (write _test-input-stream " var a: t\n")
6982 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n")
6983 (write _test-input-stream "}\n")
6984 (write _test-input-stream "type t {\n")
6985 (write _test-input-stream " x: int\n")
6986 (write _test-input-stream " y: int\n")
6987 (write _test-input-stream "}\n")
6988
6989 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
6990 (flush _test-output-buffered-file)
6991 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
6997
6998 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-local-variable/0")
6999 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-local-variable/1")
7000 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-local-variable/2")
7001 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-local-variable/3")
7002 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-local-variable/4")
7003 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-local-variable/5")
7004
7005 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-get-on-local-variable/6")
7006 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-get-on-local-variable/7")
7007
7008 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-local-variable/8")
7009
7010 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffffc) 0x00000001/r32" "F - test-convert-get-on-local-variable/9")
7011
7012 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-local-variable/10")
7013
7014 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-get-on-local-variable/11")
7015 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-local-variable/12")
7016 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-local-variable/13")
7017 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-local-variable/14")
7018 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-local-variable/15")
7019 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-local-variable/16")
7020 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-local-variable/17")
7021
7022 89/<- %esp 5/r32/ebp
7023 5d/pop-to-ebp
7024 c3/return
7025
7026 test-convert-get-on-function-argument:
7027
7028 55/push-ebp
7029 89/<- %ebp 4/r32/esp
7030
7031 (clear-stream _test-input-stream)
7032 (clear-stream $_test-input-buffered-file->buffer)
7033 (clear-stream _test-output-stream)
7034 (clear-stream $_test-output-buffered-file->buffer)
7035
7036 (write _test-input-stream "fn foo a: t {\n")
7037 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n")
7038 (write _test-input-stream "}\n")
7039 (write _test-input-stream "type t {\n")
7040 (write _test-input-stream " x: int\n")
7041 (write _test-input-stream " y: int\n")
7042 (write _test-input-stream "}\n")
7043
7044 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
7045 (flush _test-output-buffered-file)
7046 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
7052
7053 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-function-argument/0")
7054 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-function-argument/1")
7055 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-function-argument/2")
7056 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-function-argument/3")
7057 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-function-argument/4")
7058 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-function-argument/5")
7059
7060 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-function-argument/6")
7061
7062 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0x0000000c) 0x00000001/r32" "F - test-convert-get-on-function-argument/7")
7063
7064 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-function-argument/8")
7065 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-function-argument/9")
7066 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-function-argument/10")
7067 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-function-argument/11")
7068 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-function-argument/12")
7069 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-function-argument/13")
7070 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-function-argument/14")
7071
7072 89/<- %esp 5/r32/ebp
7073 5d/pop-to-ebp
7074 c3/return
7075
7076 test-convert-get-on-function-argument-with-known-type:
7077
7078 55/push-ebp
7079 89/<- %ebp 4/r32/esp
7080
7081 (clear-stream _test-input-stream)
7082 (clear-stream $_test-input-buffered-file->buffer)
7083 (clear-stream _test-output-stream)
7084 (clear-stream $_test-output-buffered-file->buffer)
7085
7086 (write _test-input-stream "type t {\n")
7087 (write _test-input-stream " x: int\n")
7088 (write _test-input-stream " y: int\n")
7089 (write _test-input-stream "}\n")
7090 (write _test-input-stream "fn foo a: t {\n")
7091 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n")
7092 (write _test-input-stream "}\n")
7093
7094 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
7095 (flush _test-output-buffered-file)
7096 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
7102
7103 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-function-argument-with-known-type/0")
7104 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-function-argument-with-known-type/1")
7105 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-function-argument-with-known-type/2")
7106 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-function-argument-with-known-type/3")
7107 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-function-argument-with-known-type/4")
7108 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-function-argument-with-known-type/5")
7109
7110 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-function-argument-with-known-type/6")
7111
7112 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0x0000000c) 0x00000001/r32" "F - test-convert-get-on-function-argument-with-known-type/7")
7113
7114 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-function-argument-with-known-type/8")
7115 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-function-argument-with-known-type/9")
7116 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-function-argument-with-known-type/10")
7117 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-function-argument-with-known-type/11")
7118 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-function-argument-with-known-type/12")
7119 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-function-argument-with-known-type/13")
7120 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-function-argument-with-known-type/14")
7121
7122 89/<- %esp 5/r32/ebp
7123 5d/pop-to-ebp
7124 c3/return
7125
7126 test-add-with-too-many-inouts:
7127
7128 55/push-ebp
7129 89/<- %ebp 4/r32/esp
7130
7131 (clear-stream _test-input-stream)
7132 (clear-stream $_test-input-buffered-file->buffer)
7133 (clear-stream _test-output-stream)
7134 (clear-stream $_test-output-buffered-file->buffer)
7135 (clear-stream _test-error-stream)
7136 (clear-stream $_test-error-buffered-file->buffer)
7137
7138 68/push 0/imm32
7139 68/push 0/imm32
7140 89/<- %edx 4/r32/esp
7141 (tailor-exit-descriptor %edx 0x10)
7142
7143 (write _test-input-stream "fn foo {\n")
7144 (write _test-input-stream " var a: int\n")
7145 (write _test-input-stream " var b/ecx: int <- add a, 0\n")
7146 (write _test-input-stream "}\n")
7147
7148 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7149
7150
7151 89/<- %edx 4/r32/esp
7152 (flush _test-output-buffered-file)
7153 (flush _test-error-buffered-file)
7154 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7160
7161 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-inouts: output should be empty")
7162 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: too many inouts; most primitives support at most two arguments, across inouts and outputs" "F - test-add-with-too-many-inouts: error message")
7163
7164 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-inouts: exit status")
7165
7166 81 0/subop/add %esp 8/imm32
7167
7168 5d/pop-to-ebp
7169 c3/return
7170
7171 test-add-with-too-many-inouts-2:
7172
7173 55/push-ebp
7174 89/<- %ebp 4/r32/esp
7175
7176 (clear-stream _test-input-stream)
7177 (clear-stream $_test-input-buffered-file->buffer)
7178 (clear-stream _test-output-stream)
7179 (clear-stream $_test-output-buffered-file->buffer)
7180 (clear-stream _test-error-stream)
7181 (clear-stream $_test-error-buffered-file->buffer)
7182
7183 68/push 0/imm32
7184 68/push 0/imm32
7185 89/<- %edx 4/r32/esp
7186 (tailor-exit-descriptor %edx 0x10)
7187
7188 (write _test-input-stream "fn foo {\n")
7189 (write _test-input-stream " var a: int\n")
7190 (write _test-input-stream " add-to a, 0, 1\n")
7191 (write _test-input-stream "}\n")
7192
7193 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7194
7195
7196 89/<- %edx 4/r32/esp
7197 (flush _test-output-buffered-file)
7198 (flush _test-error-buffered-file)
7199 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7205
7206 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-inouts-2: output should be empty")
7207 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add-to: too many inouts; most primitives support at most two arguments, across inouts and outputs" "F - test-add-with-too-many-inouts-2: error message")
7208
7209 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-inouts-2: exit status")
7210
7211 81 0/subop/add %esp 8/imm32
7212
7213 5d/pop-to-ebp
7214 c3/return
7215
7216 test-add-with-too-many-outputs:
7217
7218 55/push-ebp
7219 89/<- %ebp 4/r32/esp
7220
7221 (clear-stream _test-input-stream)
7222 (clear-stream $_test-input-buffered-file->buffer)
7223 (clear-stream _test-output-stream)
7224 (clear-stream $_test-output-buffered-file->buffer)
7225 (clear-stream _test-error-stream)
7226 (clear-stream $_test-error-buffered-file->buffer)
7227
7228 68/push 0/imm32
7229 68/push 0/imm32
7230 89/<- %edx 4/r32/esp
7231 (tailor-exit-descriptor %edx 0x10)
7232
7233 (write _test-input-stream "fn foo {\n")
7234 (write _test-input-stream " var a/eax: int <- copy 0\n")
7235 (write _test-input-stream " var b/ebx: int <- copy 0\n")
7236 (write _test-input-stream " var c/ecx: int <- copy 0\n")
7237 (write _test-input-stream " c, b <- add a\n")
7238 (write _test-input-stream "}\n")
7239
7240 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7241
7242
7243 89/<- %edx 4/r32/esp
7244 (flush _test-output-buffered-file)
7245 (flush _test-error-buffered-file)
7246 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7252
7253 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-outputs: output should be empty")
7254 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: too many outputs; most primitives support at most one output" "F - test-add-with-too-many-outputs: error message")
7255
7256 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-outputs: exit status")
7257
7258 81 0/subop/add %esp 8/imm32
7259
7260 5d/pop-to-ebp
7261 c3/return
7262
7263 test-add-with-non-number:
7264
7265 55/push-ebp
7266 89/<- %ebp 4/r32/esp
7267
7268 (clear-stream _test-input-stream)
7269 (clear-stream $_test-input-buffered-file->buffer)
7270 (clear-stream _test-output-stream)
7271 (clear-stream $_test-output-buffered-file->buffer)
7272 (clear-stream _test-error-stream)
7273 (clear-stream $_test-error-buffered-file->buffer)
7274
7275 68/push 0/imm32
7276 68/push 0/imm32
7277 89/<- %edx 4/r32/esp
7278 (tailor-exit-descriptor %edx 0x10)
7279
7280 (write _test-input-stream "fn foo {\n")
7281 (write _test-input-stream " var a: int\n")
7282 (write _test-input-stream " var b/ecx: (addr int) <- add a\n")
7283 (write _test-input-stream "}\n")
7284
7285 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7286
7287
7288 89/<- %edx 4/r32/esp
7289 (flush _test-output-buffered-file)
7290 (flush _test-error-buffered-file)
7291 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7297
7298 (check-stream-equal _test-output-stream "" "F - test-add-with-non-number: output should be empty")
7299 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: 'b' must be a non-addr non-offset scalar" "F - test-add-with-non-number: error message")
7300
7301 (check-ints-equal *(edx+4) 2 "F - test-add-with-non-number: exit status")
7302
7303 81 0/subop/add %esp 8/imm32
7304
7305 5d/pop-to-ebp
7306 c3/return
7307
7308 test-add-with-addr-dereferenced:
7309
7310 55/push-ebp
7311 89/<- %ebp 4/r32/esp
7312
7313 (clear-stream _test-input-stream)
7314 (clear-stream $_test-input-buffered-file->buffer)
7315 (clear-stream _test-output-stream)
7316 (clear-stream $_test-output-buffered-file->buffer)
7317
7318 (write _test-input-stream "fn foo {\n")
7319 (write _test-input-stream " var a/eax: (addr int) <- copy 0\n")
7320 (write _test-input-stream " add-to *a, 1\n")
7321 (write _test-input-stream "}\n")
7322
7323 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
7324 (flush _test-output-buffered-file)
7325
7326
7327 89/<- %esp 5/r32/ebp
7328 5d/pop-to-ebp
7329 c3/return
7330
7331 test-copy-with-no-inout:
7332
7333 55/push-ebp
7334 89/<- %ebp 4/r32/esp
7335
7336 (clear-stream _test-input-stream)
7337 (clear-stream $_test-input-buffered-file->buffer)
7338 (clear-stream _test-output-stream)
7339 (clear-stream $_test-output-buffered-file->buffer)
7340 (clear-stream _test-error-stream)
7341 (clear-stream $_test-error-buffered-file->buffer)
7342
7343 68/push 0/imm32
7344 68/push 0/imm32
7345 89/<- %edx 4/r32/esp
7346 (tailor-exit-descriptor %edx 0x10)
7347
7348 (write _test-input-stream "fn foo {\n")
7349 (write _test-input-stream " var x/eax: boolean <- copy\n")
7350 (write _test-input-stream "}\n")
7351
7352 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7353
7354
7355 89/<- %edx 4/r32/esp
7356 (flush _test-output-buffered-file)
7357 (flush _test-error-buffered-file)
7358 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7364
7365 (check-stream-equal _test-output-stream "" "F - test-copy-with-no-inout: output should be empty")
7366 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy' expects an inout" "F - test-copy-with-no-inout: error message")
7367
7368 (check-ints-equal *(edx+4) 2 "F - test-copy-with-no-inout: exit status")
7369
7370 81 0/subop/add %esp 8/imm32
7371
7372 5d/pop-to-ebp
7373 c3/return
7374
7375 test-copy-with-multiple-inouts:
7376
7377 55/push-ebp
7378 89/<- %ebp 4/r32/esp
7379
7380 (clear-stream _test-input-stream)
7381 (clear-stream $_test-input-buffered-file->buffer)
7382 (clear-stream _test-output-stream)
7383 (clear-stream $_test-output-buffered-file->buffer)
7384 (clear-stream _test-error-stream)
7385 (clear-stream $_test-error-buffered-file->buffer)
7386
7387 68/push 0/imm32
7388 68/push 0/imm32
7389 89/<- %edx 4/r32/esp
7390 (tailor-exit-descriptor %edx 0x10)
7391
7392 (write _test-input-stream "fn foo {\n")
7393 (write _test-input-stream " var x/eax: boolean <- copy 0, 0\n")
7394 (write _test-input-stream "}\n")
7395
7396 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7397
7398
7399 89/<- %edx 4/r32/esp
7400 (flush _test-output-buffered-file)
7401 (flush _test-error-buffered-file)
7402 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7408
7409 (check-stream-equal _test-output-stream "" "F - test-copy-with-multiple-inouts: output should be empty")
7410 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy' must have just one inout" "F - test-copy-with-multiple-inouts: error message")
7411
7412 (check-ints-equal *(edx+4) 2 "F - test-copy-with-multiple-inouts: exit status")
7413
7414 81 0/subop/add %esp 8/imm32
7415
7416 5d/pop-to-ebp
7417 c3/return
7418
7419 test-copy-with-no-output:
7420
7421 55/push-ebp
7422 89/<- %ebp 4/r32/esp
7423
7424 (clear-stream _test-input-stream)
7425 (clear-stream $_test-input-buffered-file->buffer)
7426 (clear-stream _test-output-stream)
7427 (clear-stream $_test-output-buffered-file->buffer)
7428 (clear-stream _test-error-stream)
7429 (clear-stream $_test-error-buffered-file->buffer)
7430
7431 68/push 0/imm32
7432 68/push 0/imm32
7433 89/<- %edx 4/r32/esp
7434 (tailor-exit-descriptor %edx 0x10)
7435
7436 (write _test-input-stream "fn foo {\n")
7437 (write _test-input-stream " copy 0\n")
7438 (write _test-input-stream "}\n")
7439
7440 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7441
7442
7443 89/<- %edx 4/r32/esp
7444 (flush _test-output-buffered-file)
7445 (flush _test-error-buffered-file)
7446 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7452
7453 (check-stream-equal _test-output-stream "" "F - test-copy-with-no-output: output should be empty")
7454 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy' expects an output" "F - test-copy-with-no-output: error message")
7455
7456 (check-ints-equal *(edx+4) 2 "F - test-copy-with-no-output: exit status")
7457
7458 81 0/subop/add %esp 8/imm32
7459
7460 5d/pop-to-ebp
7461 c3/return
7462
7463 test-copy-with-multiple-outputs:
7464
7465 55/push-ebp
7466 89/<- %ebp 4/r32/esp
7467
7468 (clear-stream _test-input-stream)
7469 (clear-stream $_test-input-buffered-file->buffer)
7470 (clear-stream _test-output-stream)
7471 (clear-stream $_test-output-buffered-file->buffer)
7472 (clear-stream _test-error-stream)
7473 (clear-stream $_test-error-buffered-file->buffer)
7474
7475 68/push 0/imm32
7476 68/push 0/imm32
7477 89/<- %edx 4/r32/esp
7478 (tailor-exit-descriptor %edx 0x10)
7479
7480 (write _test-input-stream "fn foo {\n")
7481 (write _test-input-stream " var x/eax: boolean <- copy 0\n")
7482 (write _test-input-stream " var y/ecx: boolean <- copy 0\n")
7483 (write _test-input-stream " x, y <- copy 0\n")
7484 (write _test-input-stream "}\n")
7485
7486 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7487
7488
7489 89/<- %edx 4/r32/esp
7490 (flush _test-output-buffered-file)
7491 (flush _test-error-buffered-file)
7492 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7498
7499 (check-stream-equal _test-output-stream "" "F - test-copy-with-multiple-outputs: output should be empty")
7500 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy' must have just one output" "F - test-copy-with-multiple-outputs: error message")
7501
7502 (check-ints-equal *(edx+4) 2 "F - test-copy-with-multiple-outputs: exit status")
7503
7504 81 0/subop/add %esp 8/imm32
7505
7506 5d/pop-to-ebp
7507 c3/return
7508
7509 test-copy-invalid-value-to-address:
7510
7511 55/push-ebp
7512 89/<- %ebp 4/r32/esp
7513
7514 (clear-stream _test-input-stream)
7515 (clear-stream $_test-input-buffered-file->buffer)
7516 (clear-stream _test-output-stream)
7517 (clear-stream $_test-output-buffered-file->buffer)
7518 (clear-stream _test-error-stream)
7519 (clear-stream $_test-error-buffered-file->buffer)
7520
7521 68/push 0/imm32
7522 68/push 0/imm32
7523 89/<- %edx 4/r32/esp
7524 (tailor-exit-descriptor %edx 0x10)
7525
7526 (write _test-input-stream "fn foo {\n")
7527 (write _test-input-stream " var x/eax: int <- copy 0\n")
7528 (write _test-input-stream " var y/ecx: (addr int) <- copy x\n")
7529 (write _test-input-stream "}\n")
7530
7531 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7532
7533
7534 89/<- %edx 4/r32/esp
7535 (flush _test-output-buffered-file)
7536 (flush _test-error-buffered-file)
7537 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7543
7544 (check-stream-equal _test-output-stream "" "F - test-copy-invalid-value-to-address: output should be empty")
7545 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy: 'y' must be a non-addr non-offset scalar" "F - test-copy-invalid-value-to-address: error message")
7546
7547 (check-ints-equal *(edx+4) 2 "F - test-copy-invalid-value-to-address: exit status")
7548
7549 81 0/subop/add %esp 8/imm32
7550
7551 5d/pop-to-ebp
7552 c3/return
7553
7554 test-copy-null-value-to-addr:
7555
7556 55/push-ebp
7557 89/<- %ebp 4/r32/esp
7558
7559 (clear-stream _test-input-stream)
7560 (clear-stream $_test-input-buffered-file->buffer)
7561 (clear-stream _test-output-stream)
7562 (clear-stream $_test-output-buffered-file->buffer)
7563
7564 (write _test-input-stream "fn foo {\n")
7565 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n")
7566 (write _test-input-stream "}\n")
7567
7568 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
7569 (flush _test-output-buffered-file)
7570 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7576
7577
7578 89/<- %esp 5/r32/ebp
7579 5d/pop-to-ebp
7580 c3/return
7581
7582 test-copy-invalid-value-to-offset:
7583
7584 55/push-ebp
7585 89/<- %ebp 4/r32/esp
7586
7587 (clear-stream _test-input-stream)
7588 (clear-stream $_test-input-buffered-file->buffer)
7589 (clear-stream _test-output-stream)
7590 (clear-stream $_test-output-buffered-file->buffer)
7591 (clear-stream _test-error-stream)
7592 (clear-stream $_test-error-buffered-file->buffer)
7593
7594 68/push 0/imm32
7595 68/push 0/imm32
7596 89/<- %edx 4/r32/esp
7597 (tailor-exit-descriptor %edx 0x10)
7598
7599 (write _test-input-stream "fn foo {\n")
7600 (write _test-input-stream " var x/eax: int <- copy 0\n")
7601 (write _test-input-stream " var y/ecx: (offset int) <- copy x\n")
7602 (write _test-input-stream "}\n")
7603
7604 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7605
7606
7607 89/<- %edx 4/r32/esp
7608 (flush _test-output-buffered-file)
7609 (flush _test-error-buffered-file)
7610 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7616
7617 (check-stream-equal _test-output-stream "" "F - test-copy-invalid-value-to-address: output should be empty")
7618 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy: 'y' must be a non-addr non-offset scalar" "F - test-copy-invalid-value-to-address: error message")
7619
7620 (check-ints-equal *(edx+4) 2 "F - test-copy-invalid-value-to-offset: exit status")
7621
7622 81 0/subop/add %esp 8/imm32
7623
7624 5d/pop-to-ebp
7625 c3/return
7626
7627 test-copy-null-value-to-offset:
7628
7629 55/push-ebp
7630 89/<- %ebp 4/r32/esp
7631
7632 (clear-stream _test-input-stream)
7633 (clear-stream $_test-input-buffered-file->buffer)
7634 (clear-stream _test-output-stream)
7635 (clear-stream $_test-output-buffered-file->buffer)
7636
7637 (write _test-input-stream "fn foo {\n")
7638 (write _test-input-stream " var y/ecx: (offset int) <- copy 0\n")
7639 (write _test-input-stream "}\n")
7640
7641 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
7642 (flush _test-output-buffered-file)
7643 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7649
7650
7651 89/<- %esp 5/r32/ebp
7652 5d/pop-to-ebp
7653 c3/return
7654
7655 test-copy-deref-address:
7656
7657 55/push-ebp
7658 89/<- %ebp 4/r32/esp
7659
7660 (clear-stream _test-input-stream)
7661 (clear-stream $_test-input-buffered-file->buffer)
7662 (clear-stream _test-output-stream)
7663 (clear-stream $_test-output-buffered-file->buffer)
7664
7665 (write _test-input-stream "fn foo {\n")
7666 (write _test-input-stream " var x/eax: (addr addr int) <- copy 0\n")
7667 (write _test-input-stream " var y/ecx: (addr int) <- copy *x\n")
7668 (write _test-input-stream "}\n")
7669
7670 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
7671 (flush _test-output-buffered-file)
7672 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7678
7679 (check-next-stream-line-equal _test-error-stream "" "F - test-copy-deref-address: error message")
7680
7681 5d/pop-to-ebp
7682 c3/return
7683
7684 test-copy-to-non-register:
7685
7686 55/push-ebp
7687 89/<- %ebp 4/r32/esp
7688
7689 (clear-stream _test-input-stream)
7690 (clear-stream $_test-input-buffered-file->buffer)
7691 (clear-stream _test-output-stream)
7692 (clear-stream $_test-output-buffered-file->buffer)
7693 (clear-stream _test-error-stream)
7694 (clear-stream $_test-error-buffered-file->buffer)
7695
7696 68/push 0/imm32
7697 68/push 0/imm32
7698 89/<- %edx 4/r32/esp
7699 (tailor-exit-descriptor %edx 0x10)
7700
7701 (write _test-input-stream "fn foo {\n")
7702 (write _test-input-stream " var x: int\n")
7703 (write _test-input-stream " x <- copy 0\n")
7704 (write _test-input-stream "}\n")
7705
7706 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7707
7708
7709 89/<- %edx 4/r32/esp
7710 (flush _test-output-buffered-file)
7711 (flush _test-error-buffered-file)
7712 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7718
7719 (check-stream-equal _test-output-stream "" "F - test-copy-to-non-register: output should be empty")
7720 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy: output 'x' not in a register" "F - test-copy-to-non-register: error message")
7721
7722 (check-ints-equal *(edx+4) 2 "F - test-copy-to-non-register: exit status")
7723
7724 81 0/subop/add %esp 8/imm32
7725
7726 5d/pop-to-ebp
7727 c3/return
7728
7729 test-copy-non-scalar:
7730
7731 55/push-ebp
7732 89/<- %ebp 4/r32/esp
7733
7734 (clear-stream _test-input-stream)
7735 (clear-stream $_test-input-buffered-file->buffer)
7736 (clear-stream _test-output-stream)
7737 (clear-stream $_test-output-buffered-file->buffer)
7738 (clear-stream _test-error-stream)
7739 (clear-stream $_test-error-buffered-file->buffer)
7740
7741 68/push 0/imm32
7742 68/push 0/imm32
7743 89/<- %edx 4/r32/esp
7744 (tailor-exit-descriptor %edx 0x10)
7745
7746 (write _test-input-stream "fn foo {\n")
7747 (write _test-input-stream " var x: (handle int)\n")
7748 (write _test-input-stream " var y/eax: int <- copy x\n")
7749 (write _test-input-stream "}\n")
7750
7751 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7752
7753
7754 89/<- %edx 4/r32/esp
7755 (flush _test-output-buffered-file)
7756 (flush _test-error-buffered-file)
7757 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7763
7764 (check-stream-equal _test-output-stream "" "F - test-copy-non-scalar: output should be empty")
7765 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy: 'x' is too large to fit in a register" "F - test-copy-non-scalar: error message")
7766
7767 (check-ints-equal *(edx+4) 2 "F - test-copy-non-scalar: exit status")
7768
7769 81 0/subop/add %esp 8/imm32
7770
7771 5d/pop-to-ebp
7772 c3/return
7773
7774 test-copy-to-with-no-inout:
7775
7776 55/push-ebp
7777 89/<- %ebp 4/r32/esp
7778
7779 (clear-stream _test-input-stream)
7780 (clear-stream $_test-input-buffered-file->buffer)
7781 (clear-stream _test-output-stream)
7782 (clear-stream $_test-output-buffered-file->buffer)
7783 (clear-stream _test-error-stream)
7784 (clear-stream $_test-error-buffered-file->buffer)
7785
7786 68/push 0/imm32
7787 68/push 0/imm32
7788 89/<- %edx 4/r32/esp
7789 (tailor-exit-descriptor %edx 0x10)
7790
7791 (write _test-input-stream "fn foo {\n")
7792 (write _test-input-stream " copy-to\n")
7793 (write _test-input-stream "}\n")
7794
7795 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7796
7797
7798 89/<- %edx 4/r32/esp
7799 (flush _test-output-buffered-file)
7800 (flush _test-error-buffered-file)
7801 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7807
7808 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-no-inout: output should be empty")
7809 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-to' must have two inouts" "F - test-copy-to-with-no-inout: error message")
7810
7811 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-no-inout: exit status")
7812
7813 81 0/subop/add %esp 8/imm32
7814
7815 5d/pop-to-ebp
7816 c3/return
7817
7818 test-copy-to-with-no-input:
7819
7820 55/push-ebp
7821 89/<- %ebp 4/r32/esp
7822
7823 (clear-stream _test-input-stream)
7824 (clear-stream $_test-input-buffered-file->buffer)
7825 (clear-stream _test-output-stream)
7826 (clear-stream $_test-output-buffered-file->buffer)
7827 (clear-stream _test-error-stream)
7828 (clear-stream $_test-error-buffered-file->buffer)
7829
7830 68/push 0/imm32
7831 68/push 0/imm32
7832 89/<- %edx 4/r32/esp
7833 (tailor-exit-descriptor %edx 0x10)
7834
7835 (write _test-input-stream "fn foo {\n")
7836 (write _test-input-stream " var x: boolean\n")
7837 (write _test-input-stream " copy-to x\n")
7838 (write _test-input-stream "}\n")
7839
7840 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7841
7842
7843 89/<- %edx 4/r32/esp
7844 (flush _test-output-buffered-file)
7845 (flush _test-error-buffered-file)
7846 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7852
7853 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-no-input: output should be empty")
7854 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-to' must have two inouts" "F - test-copy-to-with-no-input: error message")
7855
7856 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-no-input: exit status")
7857
7858 81 0/subop/add %esp 8/imm32
7859
7860 5d/pop-to-ebp
7861 c3/return
7862
7863 test-copy-to-with-no-register:
7864
7865 55/push-ebp
7866 89/<- %ebp 4/r32/esp
7867
7868 (clear-stream _test-input-stream)
7869 (clear-stream $_test-input-buffered-file->buffer)
7870 (clear-stream _test-output-stream)
7871 (clear-stream $_test-output-buffered-file->buffer)
7872 (clear-stream _test-error-stream)
7873 (clear-stream $_test-error-buffered-file->buffer)
7874
7875 68/push 0/imm32
7876 68/push 0/imm32
7877 89/<- %edx 4/r32/esp
7878 (tailor-exit-descriptor %edx 0x10)
7879
7880 (write _test-input-stream "fn foo {\n")
7881 (write _test-input-stream " var x: boolean\n")
7882 (write _test-input-stream " copy-to x, x\n")
7883 (write _test-input-stream "}\n")
7884
7885 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7886
7887
7888 89/<- %edx 4/r32/esp
7889 (flush _test-output-buffered-file)
7890 (flush _test-error-buffered-file)
7891 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7897
7898 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-no-register: output should be empty")
7899 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-to: source (second inout) is in memory" "F - test-copy-to-with-no-register: error message")
7900
7901 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-no-register: exit status")
7902
7903 81 0/subop/add %esp 8/imm32
7904
7905 5d/pop-to-ebp
7906 c3/return
7907
7908 test-copy-to-with-too-many-inouts:
7909
7910 55/push-ebp
7911 89/<- %ebp 4/r32/esp
7912
7913 (clear-stream _test-input-stream)
7914 (clear-stream $_test-input-buffered-file->buffer)
7915 (clear-stream _test-output-stream)
7916 (clear-stream $_test-output-buffered-file->buffer)
7917 (clear-stream _test-error-stream)
7918 (clear-stream $_test-error-buffered-file->buffer)
7919
7920 68/push 0/imm32
7921 68/push 0/imm32
7922 89/<- %edx 4/r32/esp
7923 (tailor-exit-descriptor %edx 0x10)
7924
7925 (write _test-input-stream "fn foo {\n")
7926 (write _test-input-stream " var x: boolean\n")
7927 (write _test-input-stream " copy-to x, 0, 0\n")
7928 (write _test-input-stream "}\n")
7929
7930 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7931
7932
7933 89/<- %edx 4/r32/esp
7934 (flush _test-output-buffered-file)
7935 (flush _test-error-buffered-file)
7936 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7942
7943 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-too-many-inouts: output should be empty")
7944 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-to' must have two inouts" "F - test-copy-to-with-too-many-inouts: error message")
7945
7946 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-too-many-inouts: exit status")
7947
7948 81 0/subop/add %esp 8/imm32
7949
7950 5d/pop-to-ebp
7951 c3/return
7952
7953 test-copy-to-with-output:
7954
7955 55/push-ebp
7956 89/<- %ebp 4/r32/esp
7957
7958 (clear-stream _test-input-stream)
7959 (clear-stream $_test-input-buffered-file->buffer)
7960 (clear-stream _test-output-stream)
7961 (clear-stream $_test-output-buffered-file->buffer)
7962 (clear-stream _test-error-stream)
7963 (clear-stream $_test-error-buffered-file->buffer)
7964
7965 68/push 0/imm32
7966 68/push 0/imm32
7967 89/<- %edx 4/r32/esp
7968 (tailor-exit-descriptor %edx 0x10)
7969
7970 (write _test-input-stream "fn foo {\n")
7971 (write _test-input-stream " var x/eax: boolean <- copy 0\n")
7972 (write _test-input-stream " var y/ecx: boolean <- copy 0\n")
7973 (write _test-input-stream " x <- copy-to y, 0\n")
7974 (write _test-input-stream "}\n")
7975
7976 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
7977
7978
7979 89/<- %edx 4/r32/esp
7980 (flush _test-output-buffered-file)
7981 (flush _test-error-buffered-file)
7982 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
7988
7989 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-output: output should be empty")
7990 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-to' must not have any outputs" "F - test-copy-to-with-output: error message")
7991
7992 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-output: exit status")
7993
7994 81 0/subop/add %esp 8/imm32
7995
7996 5d/pop-to-ebp
7997 c3/return
7998
7999 test-copy-to-invalid-value-to-address:
8000
8001 55/push-ebp
8002 89/<- %ebp 4/r32/esp
8003
8004 (clear-stream _test-input-stream)
8005 (clear-stream $_test-input-buffered-file->buffer)
8006 (clear-stream _test-output-stream)
8007 (clear-stream $_test-output-buffered-file->buffer)
8008 (clear-stream _test-error-stream)
8009 (clear-stream $_test-error-buffered-file->buffer)
8010
8011 68/push 0/imm32
8012 68/push 0/imm32
8013 89/<- %edx 4/r32/esp
8014 (tailor-exit-descriptor %edx 0x10)
8015
8016 (write _test-input-stream "fn foo {\n")
8017 (write _test-input-stream " var x/eax: int <- copy 0\n")
8018 (write _test-input-stream " var y: (addr int)\n")
8019 (write _test-input-stream " copy-to y, x\n")
8020 (write _test-input-stream "}\n")
8021
8022 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8023
8024
8025 89/<- %edx 4/r32/esp
8026 (flush _test-output-buffered-file)
8027 (flush _test-error-buffered-file)
8028 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8034
8035 (check-stream-equal _test-output-stream "" "F - test-copy-to-invalid-value-to-address: output should be empty")
8036 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-to: 'y' must be a non-addr non-offset scalar" "F - test-copy-to-invalid-value-to-address: error message")
8037
8038 (check-ints-equal *(edx+4) 2 "F - test-copy-to-invalid-value-to-address: exit status")
8039
8040 81 0/subop/add %esp 8/imm32
8041
8042 5d/pop-to-ebp
8043 c3/return
8044
8045 test-copy-to-deref-address:
8046
8047 55/push-ebp
8048 89/<- %ebp 4/r32/esp
8049
8050 (clear-stream _test-input-stream)
8051 (clear-stream $_test-input-buffered-file->buffer)
8052 (clear-stream _test-output-stream)
8053 (clear-stream $_test-output-buffered-file->buffer)
8054
8055 (write _test-input-stream "fn foo {\n")
8056 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n")
8057 (write _test-input-stream " var y/ecx: (addr addr int) <- copy 0\n")
8058 (write _test-input-stream " copy-to *y, x\n")
8059 (write _test-input-stream "}\n")
8060
8061 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
8062 (flush _test-output-buffered-file)
8063 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8069
8070 (check-next-stream-line-equal _test-error-stream "" "F - test-copy-to-deref-address: error message")
8071
8072 5d/pop-to-ebp
8073 c3/return
8074
8075 test-copy-to-non-scalar:
8076
8077 55/push-ebp
8078 89/<- %ebp 4/r32/esp
8079
8080 (clear-stream _test-input-stream)
8081 (clear-stream $_test-input-buffered-file->buffer)
8082 (clear-stream _test-output-stream)
8083 (clear-stream $_test-output-buffered-file->buffer)
8084 (clear-stream _test-error-stream)
8085 (clear-stream $_test-error-buffered-file->buffer)
8086
8087 68/push 0/imm32
8088 68/push 0/imm32
8089 89/<- %edx 4/r32/esp
8090 (tailor-exit-descriptor %edx 0x10)
8091
8092 (write _test-input-stream "fn foo {\n")
8093 (write _test-input-stream " var x: (handle int)\n")
8094 (write _test-input-stream " var y: int\n")
8095 (write _test-input-stream " copy-to y, x\n")
8096 (write _test-input-stream "}\n")
8097
8098 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8099
8100
8101 89/<- %edx 4/r32/esp
8102 (flush _test-output-buffered-file)
8103 (flush _test-error-buffered-file)
8104 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8110
8111 (check-stream-equal _test-output-stream "" "F - test-copy-to-non-scalar: output should be empty")
8112
8113 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-to: source (second inout) is in memory" "F - test-copy-to-non-scalar: error message")
8114
8115 (check-ints-equal *(edx+4) 2 "F - test-copy-to-non-scalar: exit status")
8116
8117 81 0/subop/add %esp 8/imm32
8118
8119 5d/pop-to-ebp
8120 c3/return
8121
8122 test-compare-with-no-inout:
8123
8124 55/push-ebp
8125 89/<- %ebp 4/r32/esp
8126
8127 (clear-stream _test-input-stream)
8128 (clear-stream $_test-input-buffered-file->buffer)
8129 (clear-stream _test-output-stream)
8130 (clear-stream $_test-output-buffered-file->buffer)
8131 (clear-stream _test-error-stream)
8132 (clear-stream $_test-error-buffered-file->buffer)
8133
8134 68/push 0/imm32
8135 68/push 0/imm32
8136 89/<- %edx 4/r32/esp
8137 (tailor-exit-descriptor %edx 0x10)
8138
8139 (write _test-input-stream "fn foo {\n")
8140 (write _test-input-stream " var x: boolean\n")
8141 (write _test-input-stream " compare\n")
8142 (write _test-input-stream "}\n")
8143
8144 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8145
8146
8147 89/<- %edx 4/r32/esp
8148 (flush _test-output-buffered-file)
8149 (flush _test-error-buffered-file)
8150 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8156
8157 (check-stream-equal _test-output-stream "" "F - test-compare-with-no-inout: output should be empty")
8158 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'compare' must have two inouts" "F - test-compare-with-no-inout: error message")
8159
8160 (check-ints-equal *(edx+4) 2 "F - test-compare-with-no-inout: exit status")
8161
8162 81 0/subop/add %esp 8/imm32
8163
8164 5d/pop-to-ebp
8165 c3/return
8166
8167 test-compare-with-no-input:
8168
8169 55/push-ebp
8170 89/<- %ebp 4/r32/esp
8171
8172 (clear-stream _test-input-stream)
8173 (clear-stream $_test-input-buffered-file->buffer)
8174 (clear-stream _test-output-stream)
8175 (clear-stream $_test-output-buffered-file->buffer)
8176 (clear-stream _test-error-stream)
8177 (clear-stream $_test-error-buffered-file->buffer)
8178
8179 68/push 0/imm32
8180 68/push 0/imm32
8181 89/<- %edx 4/r32/esp
8182 (tailor-exit-descriptor %edx 0x10)
8183
8184 (write _test-input-stream "fn foo {\n")
8185 (write _test-input-stream " var x: boolean\n")
8186 (write _test-input-stream " compare x\n")
8187 (write _test-input-stream "}\n")
8188
8189 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8190
8191
8192 89/<- %edx 4/r32/esp
8193 (flush _test-output-buffered-file)
8194 (flush _test-error-buffered-file)
8195 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8201
8202 (check-stream-equal _test-output-stream "" "F - test-compare-with-no-input: output should be empty")
8203 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'compare' must have two inouts" "F - test-compare-with-no-input: error message")
8204
8205 (check-ints-equal *(edx+4) 2 "F - test-compare-with-no-input: exit status")
8206
8207 81 0/subop/add %esp 8/imm32
8208
8209 5d/pop-to-ebp
8210 c3/return
8211
8212 test-compare-with-too-many-inouts:
8213
8214 55/push-ebp
8215 89/<- %ebp 4/r32/esp
8216
8217 (clear-stream _test-input-stream)
8218 (clear-stream $_test-input-buffered-file->buffer)
8219 (clear-stream _test-output-stream)
8220 (clear-stream $_test-output-buffered-file->buffer)
8221 (clear-stream _test-error-stream)
8222 (clear-stream $_test-error-buffered-file->buffer)
8223
8224 68/push 0/imm32
8225 68/push 0/imm32
8226 89/<- %edx 4/r32/esp
8227 (tailor-exit-descriptor %edx 0x10)
8228
8229 (write _test-input-stream "fn foo {\n")
8230 (write _test-input-stream " var x: boolean\n")
8231 (write _test-input-stream " compare x, 0, 0\n")
8232 (write _test-input-stream "}\n")
8233
8234 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8235
8236
8237 89/<- %edx 4/r32/esp
8238 (flush _test-output-buffered-file)
8239 (flush _test-error-buffered-file)
8240 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8246
8247 (check-stream-equal _test-output-stream "" "F - test-compare-with-too-many-inouts: output should be empty")
8248 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'compare' must have two inouts" "F - test-compare-with-too-many-inouts: error message")
8249
8250 (check-ints-equal *(edx+4) 2 "F - test-compare-with-too-many-inouts: exit status")
8251
8252 81 0/subop/add %esp 8/imm32
8253
8254 5d/pop-to-ebp
8255 c3/return
8256
8257 test-compare-with-output:
8258
8259 55/push-ebp
8260 89/<- %ebp 4/r32/esp
8261
8262 (clear-stream _test-input-stream)
8263 (clear-stream $_test-input-buffered-file->buffer)
8264 (clear-stream _test-output-stream)
8265 (clear-stream $_test-output-buffered-file->buffer)
8266 (clear-stream _test-error-stream)
8267 (clear-stream $_test-error-buffered-file->buffer)
8268
8269 68/push 0/imm32
8270 68/push 0/imm32
8271 89/<- %edx 4/r32/esp
8272 (tailor-exit-descriptor %edx 0x10)
8273
8274 (write _test-input-stream "fn foo {\n")
8275 (write _test-input-stream " var x/eax: boolean <- copy 0\n")
8276 (write _test-input-stream " var y/ecx: boolean <- copy 0\n")
8277 (write _test-input-stream " x <- compare y, 0\n")
8278 (write _test-input-stream "}\n")
8279
8280 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8281
8282
8283 89/<- %edx 4/r32/esp
8284 (flush _test-output-buffered-file)
8285 (flush _test-error-buffered-file)
8286 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8292
8293 (check-stream-equal _test-output-stream "" "F - test-compare-with-output: output should be empty")
8294 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'compare' must not have any outputs" "F - test-compare-with-output: error message")
8295
8296 (check-ints-equal *(edx+4) 2 "F - test-compare-with-output: exit status")
8297
8298 81 0/subop/add %esp 8/imm32
8299
8300 5d/pop-to-ebp
8301 c3/return
8302
8303 test-compare-invalid-value-to-address:
8304
8305 55/push-ebp
8306 89/<- %ebp 4/r32/esp
8307
8308 (clear-stream _test-input-stream)
8309 (clear-stream $_test-input-buffered-file->buffer)
8310 (clear-stream _test-output-stream)
8311 (clear-stream $_test-output-buffered-file->buffer)
8312 (clear-stream _test-error-stream)
8313 (clear-stream $_test-error-buffered-file->buffer)
8314
8315 68/push 0/imm32
8316 68/push 0/imm32
8317 89/<- %edx 4/r32/esp
8318 (tailor-exit-descriptor %edx 0x10)
8319
8320 (write _test-input-stream "fn foo {\n")
8321 (write _test-input-stream " var x/eax: int <- copy 0\n")
8322 (write _test-input-stream " var y: (addr int)\n")
8323 (write _test-input-stream " compare y, x\n")
8324 (write _test-input-stream "}\n")
8325
8326 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8327
8328
8329 89/<- %edx 4/r32/esp
8330 (flush _test-output-buffered-file)
8331 (flush _test-error-buffered-file)
8332 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8338
8339 (check-stream-equal _test-output-stream "" "F - test-compare-invalid-value-to-address: output should be empty")
8340 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compare: 'y' must be a non-addr non-offset scalar" "F - test-compare-invalid-value-to-address: error message")
8341
8342 (check-ints-equal *(edx+4) 2 "F - test-compare-invalid-value-to-address: exit status")
8343
8344 81 0/subop/add %esp 8/imm32
8345
8346 5d/pop-to-ebp
8347 c3/return
8348
8349 test-compare-address:
8350
8351 55/push-ebp
8352 89/<- %ebp 4/r32/esp
8353
8354 (clear-stream _test-input-stream)
8355 (clear-stream $_test-input-buffered-file->buffer)
8356 (clear-stream _test-output-stream)
8357 (clear-stream $_test-output-buffered-file->buffer)
8358
8359 (write _test-input-stream "fn foo {\n")
8360 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n")
8361 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n")
8362 (write _test-input-stream " compare y, x\n")
8363 (write _test-input-stream "}\n")
8364
8365 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
8366 (flush _test-output-buffered-file)
8367 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8373
8374 (check-next-stream-line-equal _test-error-stream "" "F - test-compare-address: error message")
8375
8376 5d/pop-to-ebp
8377 c3/return
8378
8379 test-compare-deref-address:
8380
8381 55/push-ebp
8382 89/<- %ebp 4/r32/esp
8383
8384 (clear-stream _test-input-stream)
8385 (clear-stream $_test-input-buffered-file->buffer)
8386 (clear-stream _test-output-stream)
8387 (clear-stream $_test-output-buffered-file->buffer)
8388
8389 (write _test-input-stream "fn foo {\n")
8390 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n")
8391 (write _test-input-stream " var y/ecx: (addr addr int) <- copy 0\n")
8392 (write _test-input-stream " compare *y, x\n")
8393 (write _test-input-stream "}\n")
8394
8395 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
8396 (flush _test-output-buffered-file)
8397 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8403
8404 (check-next-stream-line-equal _test-error-stream "" "F - test-compare-deref-address: error message")
8405
8406 5d/pop-to-ebp
8407 c3/return
8408
8409 test-compare-two-vars-in-memory:
8410
8411 55/push-ebp
8412 89/<- %ebp 4/r32/esp
8413
8414 (clear-stream _test-input-stream)
8415 (clear-stream $_test-input-buffered-file->buffer)
8416 (clear-stream _test-output-stream)
8417 (clear-stream $_test-output-buffered-file->buffer)
8418 (clear-stream _test-error-stream)
8419 (clear-stream $_test-error-buffered-file->buffer)
8420
8421 68/push 0/imm32
8422 68/push 0/imm32
8423 89/<- %edx 4/r32/esp
8424 (tailor-exit-descriptor %edx 0x10)
8425
8426 (write _test-input-stream "fn foo {\n")
8427 (write _test-input-stream " var x: boolean\n")
8428 (write _test-input-stream " compare x, x\n")
8429 (write _test-input-stream "}\n")
8430
8431 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8432
8433
8434 89/<- %edx 4/r32/esp
8435 (flush _test-output-buffered-file)
8436 (flush _test-error-buffered-file)
8437 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8443
8444 (check-stream-equal _test-output-stream "" "F - test-compare-two-vars-in-memory: output should be empty")
8445 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compare: both inouts are in memory" "F - test-compare-two-vars-in-memory: error message")
8446
8447 (check-ints-equal *(edx+4) 2 "F - test-compare-two-vars-in-memory: exit status")
8448
8449 81 0/subop/add %esp 8/imm32
8450
8451 5d/pop-to-ebp
8452 c3/return
8453
8454 test-compare-non-scalar:
8455
8456 55/push-ebp
8457 89/<- %ebp 4/r32/esp
8458
8459 (clear-stream _test-input-stream)
8460 (clear-stream $_test-input-buffered-file->buffer)
8461 (clear-stream _test-output-stream)
8462 (clear-stream $_test-output-buffered-file->buffer)
8463 (clear-stream _test-error-stream)
8464 (clear-stream $_test-error-buffered-file->buffer)
8465
8466 68/push 0/imm32
8467 68/push 0/imm32
8468 89/<- %edx 4/r32/esp
8469 (tailor-exit-descriptor %edx 0x10)
8470
8471 (write _test-input-stream "fn foo {\n")
8472 (write _test-input-stream " var x: (handle int)\n")
8473 (write _test-input-stream " var y: int\n")
8474 (write _test-input-stream " compare y, x\n")
8475 (write _test-input-stream "}\n")
8476
8477 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8478
8479
8480 89/<- %edx 4/r32/esp
8481 (flush _test-output-buffered-file)
8482 (flush _test-error-buffered-file)
8483 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8489
8490 (check-stream-equal _test-output-stream "" "F - test-compare-non-scalar: output should be empty")
8491
8492 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compare: both inouts are in memory" "F - test-compare-non-scalar: error message")
8493
8494 (check-ints-equal *(edx+4) 2 "F - test-compare-non-scalar: exit status")
8495
8496 81 0/subop/add %esp 8/imm32
8497
8498 5d/pop-to-ebp
8499 c3/return
8500
8501 test-address-with-no-inout:
8502
8503 55/push-ebp
8504 89/<- %ebp 4/r32/esp
8505
8506 (clear-stream _test-input-stream)
8507 (clear-stream $_test-input-buffered-file->buffer)
8508 (clear-stream _test-output-stream)
8509 (clear-stream $_test-output-buffered-file->buffer)
8510 (clear-stream _test-error-stream)
8511 (clear-stream $_test-error-buffered-file->buffer)
8512
8513 68/push 0/imm32
8514 68/push 0/imm32
8515 89/<- %edx 4/r32/esp
8516 (tailor-exit-descriptor %edx 0x10)
8517
8518 (write _test-input-stream "fn foo {\n")
8519 (write _test-input-stream " var x/eax: boolean <- address\n")
8520 (write _test-input-stream "}\n")
8521
8522 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8523
8524
8525 89/<- %edx 4/r32/esp
8526 (flush _test-output-buffered-file)
8527 (flush _test-error-buffered-file)
8528 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8534
8535 (check-stream-equal _test-output-stream "" "F - test-address-with-no-inout: output should be empty")
8536 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'address' expects an inout" "F - test-address-with-no-inout: error message")
8537
8538 (check-ints-equal *(edx+4) 2 "F - test-address-with-no-inout: exit status")
8539
8540 81 0/subop/add %esp 8/imm32
8541
8542 5d/pop-to-ebp
8543 c3/return
8544
8545 test-address-with-multiple-inouts:
8546
8547 55/push-ebp
8548 89/<- %ebp 4/r32/esp
8549
8550 (clear-stream _test-input-stream)
8551 (clear-stream $_test-input-buffered-file->buffer)
8552 (clear-stream _test-output-stream)
8553 (clear-stream $_test-output-buffered-file->buffer)
8554 (clear-stream _test-error-stream)
8555 (clear-stream $_test-error-buffered-file->buffer)
8556
8557 68/push 0/imm32
8558 68/push 0/imm32
8559 89/<- %edx 4/r32/esp
8560 (tailor-exit-descriptor %edx 0x10)
8561
8562 (write _test-input-stream "fn foo {\n")
8563 (write _test-input-stream " var x/eax: boolean <- address 0, 0\n")
8564 (write _test-input-stream "}\n")
8565
8566 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8567
8568
8569 89/<- %edx 4/r32/esp
8570 (flush _test-output-buffered-file)
8571 (flush _test-error-buffered-file)
8572 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8578
8579 (check-stream-equal _test-output-stream "" "F - test-address-with-multiple-inouts: output should be empty")
8580 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'address' must have just one inout" "F - test-address-with-multiple-inouts: error message")
8581
8582 (check-ints-equal *(edx+4) 2 "F - test-address-with-multiple-inouts: exit status")
8583
8584 81 0/subop/add %esp 8/imm32
8585
8586 5d/pop-to-ebp
8587 c3/return
8588
8589 test-address-with-no-output:
8590
8591 55/push-ebp
8592 89/<- %ebp 4/r32/esp
8593
8594 (clear-stream _test-input-stream)
8595 (clear-stream $_test-input-buffered-file->buffer)
8596 (clear-stream _test-output-stream)
8597 (clear-stream $_test-output-buffered-file->buffer)
8598 (clear-stream _test-error-stream)
8599 (clear-stream $_test-error-buffered-file->buffer)
8600
8601 68/push 0/imm32
8602 68/push 0/imm32
8603 89/<- %edx 4/r32/esp
8604 (tailor-exit-descriptor %edx 0x10)
8605
8606 (write _test-input-stream "fn foo {\n")
8607 (write _test-input-stream " address 0\n")
8608 (write _test-input-stream "}\n")
8609
8610 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8611
8612
8613 89/<- %edx 4/r32/esp
8614 (flush _test-output-buffered-file)
8615 (flush _test-error-buffered-file)
8616 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8622
8623 (check-stream-equal _test-output-stream "" "F - test-address-with-no-output: output should be empty")
8624 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'address' expects an output" "F - test-address-with-no-output: error message")
8625
8626 (check-ints-equal *(edx+4) 2 "F - test-address-with-no-output: exit status")
8627
8628 81 0/subop/add %esp 8/imm32
8629
8630 5d/pop-to-ebp
8631 c3/return
8632
8633 test-address-with-multiple-outputs:
8634
8635 55/push-ebp
8636 89/<- %ebp 4/r32/esp
8637
8638 (clear-stream _test-input-stream)
8639 (clear-stream $_test-input-buffered-file->buffer)
8640 (clear-stream _test-output-stream)
8641 (clear-stream $_test-output-buffered-file->buffer)
8642 (clear-stream _test-error-stream)
8643 (clear-stream $_test-error-buffered-file->buffer)
8644
8645 68/push 0/imm32
8646 68/push 0/imm32
8647 89/<- %edx 4/r32/esp
8648 (tailor-exit-descriptor %edx 0x10)
8649
8650 (write _test-input-stream "fn foo {\n")
8651 (write _test-input-stream " var x/eax: boolean <- copy 0\n")
8652 (write _test-input-stream " var y/ecx: boolean <- copy 0\n")
8653 (write _test-input-stream " x, y <- address 0\n")
8654 (write _test-input-stream "}\n")
8655
8656 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8657
8658
8659 89/<- %edx 4/r32/esp
8660 (flush _test-output-buffered-file)
8661 (flush _test-error-buffered-file)
8662 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8668
8669 (check-stream-equal _test-output-stream "" "F - test-address-with-multiple-outputs: output should be empty")
8670 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'address' must have just one output" "F - test-address-with-multiple-outputs: error message")
8671
8672 (check-ints-equal *(edx+4) 2 "F - test-address-with-multiple-outputs: exit status")
8673
8674 81 0/subop/add %esp 8/imm32
8675
8676 5d/pop-to-ebp
8677 c3/return
8678
8679
8680 test-address-of-deref:
8681
8682 55/push-ebp
8683 89/<- %ebp 4/r32/esp
8684
8685 (clear-stream _test-input-stream)
8686 (clear-stream $_test-input-buffered-file->buffer)
8687 (clear-stream _test-output-stream)
8688 (clear-stream $_test-output-buffered-file->buffer)
8689
8690 (write _test-input-stream "fn foo {\n")
8691 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n")
8692 (write _test-input-stream " var y/ecx: (addr int) <- address *x\n")
8693 (write _test-input-stream "}\n")
8694
8695 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
8696 (flush _test-output-buffered-file)
8697 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8703
8704 (check-next-stream-line-equal _test-error-stream "" "F - test-address-of-deref: error message")
8705
8706 5d/pop-to-ebp
8707 c3/return
8708
8709 test-address-to-non-register:
8710
8711 55/push-ebp
8712 89/<- %ebp 4/r32/esp
8713
8714 (clear-stream _test-input-stream)
8715 (clear-stream $_test-input-buffered-file->buffer)
8716 (clear-stream _test-output-stream)
8717 (clear-stream $_test-output-buffered-file->buffer)
8718 (clear-stream _test-error-stream)
8719 (clear-stream $_test-error-buffered-file->buffer)
8720
8721 68/push 0/imm32
8722 68/push 0/imm32
8723 89/<- %edx 4/r32/esp
8724 (tailor-exit-descriptor %edx 0x10)
8725
8726 (write _test-input-stream "fn foo {\n")
8727 (write _test-input-stream " var x: (addr int)\n")
8728 (write _test-input-stream " x <- address 0\n")
8729 (write _test-input-stream "}\n")
8730
8731 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8732
8733
8734 89/<- %edx 4/r32/esp
8735 (flush _test-output-buffered-file)
8736 (flush _test-error-buffered-file)
8737 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8743
8744 (check-stream-equal _test-output-stream "" "F - test-address-to-non-register: output should be empty")
8745 (check-next-stream-line-equal _test-error-stream "fn foo: stmt address: output 'x' not in a register" "F - test-address-to-non-register: error message")
8746
8747 (check-ints-equal *(edx+4) 2 "F - test-address-to-non-register: exit status")
8748
8749 81 0/subop/add %esp 8/imm32
8750
8751 5d/pop-to-ebp
8752 c3/return
8753
8754 test-address-with-wrong-type:
8755
8756 55/push-ebp
8757 89/<- %ebp 4/r32/esp
8758
8759 (clear-stream _test-input-stream)
8760 (clear-stream $_test-input-buffered-file->buffer)
8761 (clear-stream _test-output-stream)
8762 (clear-stream $_test-output-buffered-file->buffer)
8763 (clear-stream _test-error-stream)
8764 (clear-stream $_test-error-buffered-file->buffer)
8765
8766 68/push 0/imm32
8767 68/push 0/imm32
8768 89/<- %edx 4/r32/esp
8769 (tailor-exit-descriptor %edx 0x10)
8770
8771 (write _test-input-stream "fn foo {\n")
8772 (write _test-input-stream " var x: int\n")
8773 (write _test-input-stream " var y/eax: (addr boolean) <- address x\n")
8774 (write _test-input-stream "}\n")
8775
8776 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8777
8778
8779 89/<- %edx 4/r32/esp
8780 (flush _test-output-buffered-file)
8781 (flush _test-error-buffered-file)
8782 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8788
8789 (check-stream-equal _test-output-stream "" "F - test-address-with-wrong-type: output should be empty")
8790 (check-next-stream-line-equal _test-error-stream "fn foo: stmt address: output 'y' cannot hold address of 'x'" "F - test-address-with-wrong-type: error message")
8791
8792 (check-ints-equal *(edx+4) 2 "F - test-address-with-wrong-type: exit status")
8793
8794 81 0/subop/add %esp 8/imm32
8795
8796 5d/pop-to-ebp
8797 c3/return
8798
8799 test-address-with-right-type-for-array:
8800
8801 55/push-ebp
8802 89/<- %ebp 4/r32/esp
8803
8804 (clear-stream _test-input-stream)
8805 (clear-stream $_test-input-buffered-file->buffer)
8806 (clear-stream _test-output-stream)
8807 (clear-stream $_test-output-buffered-file->buffer)
8808
8809 (write _test-input-stream "fn foo {\n")
8810 (write _test-input-stream " var x: (array int 3)\n")
8811 (write _test-input-stream " var y/eax: (addr array int) <- address x\n")
8812 (write _test-input-stream "}\n")
8813
8814 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
8815 (flush _test-output-buffered-file)
8816 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8822
8823 (check-next-stream-line-equal _test-error-stream "" "F - test-address-with-right-type-for-array: error message")
8824
8825
8826 89/<- %esp 5/r32/ebp
8827 5d/pop-to-ebp
8828 c3/return
8829
8830 test-address-with-right-type-for-stream:
8831
8832 55/push-ebp
8833 89/<- %ebp 4/r32/esp
8834
8835 (clear-stream _test-input-stream)
8836 (clear-stream $_test-input-buffered-file->buffer)
8837 (clear-stream _test-output-stream)
8838 (clear-stream $_test-output-buffered-file->buffer)
8839
8840 (write _test-input-stream "fn foo {\n")
8841 (write _test-input-stream " var x: (stream int 3)\n")
8842 (write _test-input-stream " var y/eax: (addr stream int) <- address x\n")
8843 (write _test-input-stream "}\n")
8844
8845 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
8846 (flush _test-output-buffered-file)
8847 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8853
8854 (check-next-stream-line-equal _test-error-stream "" "F - test-address-with-right-type-for-stream: error message")
8855
8856
8857 89/<- %esp 5/r32/ebp
8858 5d/pop-to-ebp
8859 c3/return
8860
8861 test-get-with-wrong-field:
8862
8863 55/push-ebp
8864 89/<- %ebp 4/r32/esp
8865
8866 (clear-stream _test-input-stream)
8867 (clear-stream $_test-input-buffered-file->buffer)
8868 (clear-stream _test-output-stream)
8869 (clear-stream $_test-output-buffered-file->buffer)
8870 (clear-stream _test-error-stream)
8871 (clear-stream $_test-error-buffered-file->buffer)
8872
8873 68/push 0/imm32
8874 68/push 0/imm32
8875 89/<- %edx 4/r32/esp
8876 (tailor-exit-descriptor %edx 0x10)
8877
8878 (write _test-input-stream "fn foo {\n")
8879 (write _test-input-stream " var a: t\n")
8880 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n")
8881 (write _test-input-stream "}\n")
8882 (write _test-input-stream "type t {\n")
8883 (write _test-input-stream " x: int\n")
8884 (write _test-input-stream "}\n")
8885
8886 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8887
8888
8889 89/<- %edx 4/r32/esp
8890 (flush _test-output-buffered-file)
8891 (flush _test-error-buffered-file)
8892 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8898
8899 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-field: output should be empty")
8900 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: type 't' has no member called 'y'" "F - test-get-with-wrong-field: error message")
8901
8902 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-field: exit status")
8903
8904 81 0/subop/add %esp 8/imm32
8905
8906 5d/pop-to-ebp
8907 c3/return
8908
8909 test-get-with-wrong-base-type:
8910
8911 55/push-ebp
8912 89/<- %ebp 4/r32/esp
8913
8914 (clear-stream _test-input-stream)
8915 (clear-stream $_test-input-buffered-file->buffer)
8916 (clear-stream _test-output-stream)
8917 (clear-stream $_test-output-buffered-file->buffer)
8918 (clear-stream _test-error-stream)
8919 (clear-stream $_test-error-buffered-file->buffer)
8920
8921 68/push 0/imm32
8922 68/push 0/imm32
8923 89/<- %edx 4/r32/esp
8924 (tailor-exit-descriptor %edx 0x10)
8925
8926 (write _test-input-stream "fn foo {\n")
8927 (write _test-input-stream " var a: int\n")
8928 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n")
8929 (write _test-input-stream "}\n")
8930
8931 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8932
8933
8934 89/<- %edx 4/r32/esp
8935 (flush _test-output-buffered-file)
8936 (flush _test-error-buffered-file)
8937 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8943
8944 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type: output should be empty")
8945 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' must have a 'type' definition" "F - test-get-with-wrong-base-type: error message")
8946
8947 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-base-type: exit status")
8948
8949 81 0/subop/add %esp 8/imm32
8950
8951 5d/pop-to-ebp
8952 c3/return
8953
8954 test-get-with-wrong-base-type-2:
8955
8956 55/push-ebp
8957 89/<- %ebp 4/r32/esp
8958
8959 (clear-stream _test-input-stream)
8960 (clear-stream $_test-input-buffered-file->buffer)
8961 (clear-stream _test-output-stream)
8962 (clear-stream $_test-output-buffered-file->buffer)
8963 (clear-stream _test-error-stream)
8964 (clear-stream $_test-error-buffered-file->buffer)
8965
8966 68/push 0/imm32
8967 68/push 0/imm32
8968 89/<- %edx 4/r32/esp
8969 (tailor-exit-descriptor %edx 0x10)
8970
8971 (write _test-input-stream "fn foo {\n")
8972 (write _test-input-stream " var a: (addr t)\n")
8973 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n")
8974 (write _test-input-stream "}\n")
8975 (write _test-input-stream "type t {\n")
8976 (write _test-input-stream " x: int\n")
8977 (write _test-input-stream "}\n")
8978
8979 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
8980
8981
8982 89/<- %edx 4/r32/esp
8983 (flush _test-output-buffered-file)
8984 (flush _test-error-buffered-file)
8985 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
8991
8992 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type-2: output should be empty")
8993 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' is an 'addr' type, and so must live in a register" "F - test-get-with-wrong-base-type-2: error message")
8994
8995 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-base-type-2: exit status")
8996
8997 81 0/subop/add %esp 8/imm32
8998
8999 5d/pop-to-ebp
9000 c3/return
9001
9002 test-get-with-wrong-base-type-3:
9003
9004 55/push-ebp
9005 89/<- %ebp 4/r32/esp
9006
9007 (clear-stream _test-input-stream)
9008 (clear-stream $_test-input-buffered-file->buffer)
9009 (clear-stream _test-output-stream)
9010 (clear-stream $_test-output-buffered-file->buffer)
9011 (clear-stream _test-error-stream)
9012 (clear-stream $_test-error-buffered-file->buffer)
9013
9014 68/push 0/imm32
9015 68/push 0/imm32
9016 89/<- %edx 4/r32/esp
9017 (tailor-exit-descriptor %edx 0x10)
9018
9019 (write _test-input-stream "fn foo {\n")
9020 (write _test-input-stream " var a: (handle int)\n")
9021 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n")
9022 (write _test-input-stream "}\n")
9023
9024 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
9025
9026
9027 89/<- %edx 4/r32/esp
9028 (flush _test-output-buffered-file)
9029 (flush _test-error-buffered-file)
9030 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
9036
9037 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type-3: output should be empty")
9038 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' must have a 'type' definition" "F - test-get-with-wrong-base-type-3: error message")
9039
9040 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-base-type-3: exit status")
9041
9042 81 0/subop/add %esp 8/imm32
9043
9044 5d/pop-to-ebp
9045 c3/return
9046
9047 test-get-with-wrong-offset-type:
9048
9049 55/push-ebp
9050 89/<- %ebp 4/r32/esp
9051
9052 (clear-stream _test-input-stream)
9053 (clear-stream $_test-input-buffered-file->buffer)
9054 (clear-stream _test-output-stream)
9055 (clear-stream $_test-output-buffered-file->buffer)
9056 (clear-stream _test-error-stream)
9057 (clear-stream $_test-error-buffered-file->buffer)
9058
9059 68/push 0/imm32
9060 68/push 0/imm32
9061 89/<- %edx 4/r32/esp
9062 (tailor-exit-descriptor %edx 0x10)
9063
9064 (write _test-input-stream "fn foo {\n")
9065 (write _test-input-stream " var a: t\n")
9066 (write _test-input-stream " var b: int\n")
9067 (write _test-input-stream " var c/ecx: (addr int) <- get a, b\n")
9068 (write _test-input-stream "}\n")
9069 (write _test-input-stream "type t {\n")
9070 (write _test-input-stream " x: int\n")
9071 (write _test-input-stream "}\n")
9072
9073 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
9074
9075
9076 89/<- %edx 4/r32/esp
9077 (flush _test-output-buffered-file)
9078 (flush _test-error-buffered-file)
9079 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
9085
9086 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-offset-type: output should be empty")
9087 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: type 't' has no member called 'b'" "F - test-get-with-wrong-offset-type: error message")
9088
9089 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-offset-type: exit status")
9090
9091 81 0/subop/add %esp 8/imm32
9092
9093 5d/pop-to-ebp
9094 c3/return
9095
9096 test-get-with-wrong-output-type:
9097
9098 55/push-ebp
9099 89/<- %ebp 4/r32/esp
9100
9101 (clear-stream _test-input-stream)
9102 (clear-stream $_test-input-buffered-file->buffer)
9103 (clear-stream _test-output-stream)
9104 (clear-stream $_test-output-buffered-file->buffer)
9105 (clear-stream _test-error-stream)
9106 (clear-stream $_test-error-buffered-file->buffer)
9107
9108 68/push 0/imm32
9109 68/push 0/imm32
9110 89/<- %edx 4/r32/esp
9111 (tailor-exit-descriptor %edx 0x10)
9112
9113 (write _test-input-stream "fn foo {\n")
9114 (write _test-input-stream " var a: t\n")
9115 (write _test-input-stream " var c: (addr int)\n")
9116 (write _test-input-stream " c <- get a, x\n")
9117 (write _test-input-stream "}\n")
9118 (write _test-input-stream "type t {\n")
9119 (write _test-input-stream " x: int\n")
9120 (write _test-input-stream "}\n")
9121
9122 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
9123
9124
9125 89/<- %edx 4/r32/esp
9126 (flush _test-output-buffered-file)
9127 (flush _test-error-buffered-file)
9128 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
9134
9135 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type: output should be empty")
9136 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output 'c' is not in a register" "F - test-get-with-wrong-output-type: error message")
9137
9138 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type: exit status")
9139
9140 81 0/subop/add %esp 8/imm32
9141
9142 5d/pop-to-ebp
9143 c3/return
9144
9145 test-get-with-wrong-output-type-2:
9146
9147 55/push-ebp
9148 89/<- %ebp 4/r32/esp
9149
9150 (clear-stream _test-input-stream)
9151 (clear-stream $_test-input-buffered-file->buffer)
9152 (clear-stream _test-output-stream)
9153 (clear-stream $_test-output-buffered-file->buffer)
9154 (clear-stream _test-error-stream)
9155 (clear-stream $_test-error-buffered-file->buffer)
9156
9157 68/push 0/imm32
9158 68/push 0/imm32
9159 89/<- %edx 4/r32/esp
9160 (tailor-exit-descriptor %edx 0x10)
9161
9162 (write _test-input-stream "fn foo {\n")
9163 (write _test-input-stream " var a: t\n")
9164 (write _test-input-stream " var c/ecx: int <- get a, x\n")
9165 (write _test-input-stream "}\n")
9166 (write _test-input-stream "type t {\n")
9167 (write _test-input-stream " x: int\n")
9168 (write _test-input-stream "}\n")
9169
9170 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
9171
9172
9173 89/<- %edx 4/r32/esp
9174 (flush _test-output-buffered-file)
9175 (flush _test-error-buffered-file)
9176 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
9182
9183 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-2: output should be empty")
9184 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output must be an addr" "F - test-get-with-wrong-output-type-2: error message")
9185
9186 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-2: exit status")
9187
9188 81 0/subop/add %esp 8/imm32
9189
9190 5d/pop-to-ebp
9191 c3/return
9192
9193 test-get-with-wrong-output-type-3:
9194
9195 55/push-ebp
9196 89/<- %ebp 4/r32/esp
9197
9198 (clear-stream _test-input-stream)
9199 (clear-stream $_test-input-buffered-file->buffer)
9200 (clear-stream _test-output-stream)
9201 (clear-stream $_test-output-buffered-file->buffer)
9202 (clear-stream _test-error-stream)
9203 (clear-stream $_test-error-buffered-file->buffer)
9204
9205 68/push 0/imm32
9206 68/push 0/imm32
9207 89/<- %edx 4/r32/esp
9208 (tailor-exit-descriptor %edx 0x10)
9209
9210 (write _test-input-stream "fn foo {\n")
9211 (write _test-input-stream " var a: t\n")
9212 (write _test-input-stream " var c/ecx: (array int) <- get a, x\n")
9213 (write _test-input-stream "}\n")
9214 (write _test-input-stream "type t {\n")
9215 (write _test-input-stream " x: int\n")
9216 (write _test-input-stream "}\n")
9217
9218 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
9219
9220
9221 89/<- %edx 4/r32/esp
9222 (flush _test-output-buffered-file)
9223 (flush _test-error-buffered-file)
9224 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
9230
9231 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-3: output should be empty")
9232 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output must be an addr" "F - test-get-with-wrong-output-type-3: error message")
9233
9234 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-3: exit status")
9235
9236 81 0/subop/add %esp 8/imm32
9237
9238 5d/pop-to-ebp
9239 c3/return
9240
9241 test-get-with-wrong-output-type-4:
9242
9243 55/push-ebp
9244 89/<- %ebp 4/r32/esp
9245
9246 (clear-stream _test-input-stream)
9247 (clear-stream $_test-input-buffered-file->buffer)
9248 (clear-stream _test-output-stream)
9249 (clear-stream $_test-output-buffered-file->buffer)
9250 (clear-stream _test-error-stream)
9251 (clear-stream $_test-error-buffered-file->buffer)
9252
9253 68/push 0/imm32
9254 68/push 0/imm32
9255 89/<- %edx 4/r32/esp
9256 (tailor-exit-descriptor %edx 0x10)
9257
9258 (write _test-input-stream "fn foo {\n")
9259 (write _test-input-stream " var a: t\n")
9260 (write _test-input-stream " var c/ecx: (addr boolean) <- get a, x\n")
9261 (write _test-input-stream "}\n")
9262 (write _test-input-stream "type t {\n")
9263 (write _test-input-stream " x: int\n")
9264 (write _test-input-stream "}\n")
9265
9266 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
9267
9268
9269 89/<- %edx 4/r32/esp
9270 (flush _test-output-buffered-file)
9271 (flush _test-error-buffered-file)
9272 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
9278
9279 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-4: output should be empty")
9280 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: wrong output type for member 'x' of type 't'" "F - test-get-with-wrong-output-type-4: error message")
9281
9282 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-4: exit status")
9283
9284 81 0/subop/add %esp 8/imm32
9285
9286 5d/pop-to-ebp
9287 c3/return
9288
9289 test-get-with-wrong-output-type-5:
9290
9291 55/push-ebp
9292 89/<- %ebp 4/r32/esp
9293
9294 (clear-stream _test-input-stream)
9295 (clear-stream $_test-input-buffered-file->buffer)
9296 (clear-stream _test-output-stream)
9297 (clear-stream $_test-output-buffered-file->buffer)
9298
9299 (write _test-input-stream "fn foo {\n")
9300 (write _test-input-stream " var a: t\n")
9301 (write _test-input-stream " var c/ecx: (addr handle int) <- get a, x\n")
9302 (write _test-input-stream "}\n")
9303 (write _test-input-stream "type t {\n")
9304 (write _test-input-stream " x: (handle int)\n")
9305 (write _test-input-stream "}\n")
9306
9307 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
9308 (flush _test-output-buffered-file)
9309
9310
9311 89/<- %esp 5/r32/ebp
9312 5d/pop-to-ebp
9313 c3/return
9314
9315 test-get-with-too-few-inouts:
9316
9317 55/push-ebp
9318 89/<- %ebp 4/r32/esp
9319
9320 (clear-stream _test-input-stream)
9321 (clear-stream $_test-input-buffered-file->buffer)
9322 (clear-stream _test-output-stream)
9323 (clear-stream $_test-output-buffered-file->buffer)
9324 (clear-stream _test-error-stream)
9325 (clear-stream $_test-error-buffered-file->buffer)
9326
9327 68/push 0/imm32
9328 68/push 0/imm32
9329 89/<- %edx 4/r32/esp
9330 (tailor-exit-descriptor %edx 0x10)
9331
9332 (write _test-input-stream "fn foo {\n")
9333 (write _test-input-stream " var a: t\n")
9334 (write _test-input-stream " var c/ecx: (addr int) <- get a\n")
9335 (write _test-input-stream "}\n")
9336 (write _test-input-stream "type t {\n")
9337 (write _test-input-stream " x: int\n")
9338 (write _test-input-stream "}\n")
9339
9340 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
9341
9342
9343 89/<- %edx 4/r32/esp
9344 (flush _test-output-buffered-file)
9345 (flush _test-error-buffered-file)
9346 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
9352
9353 (check-stream-equal _test-output-stream "" "F - test-get-with-too-few-inouts: output should be empty")
9354 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too few inouts (2 required)" "F - test-get-with-too-few-inouts: error message")
9355
9356 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-few-inouts: exit status")
9357
9358 81 0/subop/add %esp 8/imm32
9359
9360 5d/pop-to-ebp
9361 c3/return
9362
9363 test-get-with-too-many-inouts:
9364
9365 55/push-ebp
9366 89/<- %ebp 4/r32/esp
9367
9368 (clear-stream _test-input-stream)
9369 (clear-stream $_test-input-buffered-file->buffer)
9370 (clear-stream _test-output-stream)
9371 (clear-stream $_test-output-buffered-file->buffer)
9372 (clear-stream _test-error-stream)
9373 (clear-stream $_test-error-buffered-file->buffer)
9374
9375 68/push 0/imm32
9376 68/push 0/imm32
9377 89/<- %edx 4/r32/esp
9378 (tailor-exit-descriptor %edx 0x10)
9379
9380 (write _test-input-stream "fn foo {\n")
9381 (write _test-input-stream " var a: t\n")
9382 (write _test-input-stream " var c/ecx: (addr int) <- get a, x, 0\n")
9383 (write _test-input-stream "}\n")
9384 (write _test-input-stream "type t {\n")
9385 (write _test-input-stream " x: int\n")
9386 (write _test-input-stream "}\n")
9387
9388 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
9389
9390
9391 89/<- %edx 4/r32/esp
9392 (flush _test-output-buffered-file)
9393 (flush _test-error-buffered-file)
9394 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
9400
9401 (check-stream-equal _test-output-stream "" "F - test-get-with-too-many-inouts: output should be empty")
9402 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too many inouts (2 required)" "F - test-get-with-too-many-inouts: error message")
9403
9404 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-many-inouts: exit status")
9405
9406 81 0/subop/add %esp 8/imm32
9407
9408 5d/pop-to-ebp
9409 c3/return
9410
9411 test-get-with-no-output:
9412
9413 55/push-ebp
9414 89/<- %ebp 4/r32/esp
9415
9416 (clear-stream _test-input-stream)
9417 (clear-stream $_test-input-buffered-file->buffer)
9418 (clear-stream _test-output-stream)
9419 (clear-stream $_test-output-buffered-file->buffer)
9420 (clear-stream _test-error-stream)
9421 (clear-stream $_test-error-buffered-file->buffer)
9422
9423 68/push 0/imm32
9424 68/push 0/imm32
9425 89/<- %edx 4/r32/esp
9426 (tailor-exit-descriptor %edx 0x10)
9427
9428 (write _test-input-stream "fn foo {\n")
9429 (write _test-input-stream " var a: t\n")
9430 (write _test-input-stream " get a, x\n")
9431 (write _test-input-stream "}\n")
9432 (write _test-input-stream "type t {\n")
9433 (write _test-input-stream " x: int\n")
9434 (write _test-input-stream "}\n")
9435
9436 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
9437
9438
9439 89/<- %edx 4/r32/esp
9440 (flush _test-output-buffered-file)
9441 (flush _test-error-buffered-file)
9442 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
9448
9449 (check-stream-equal _test-output-stream "" "F - test-get-with-no-output: output should be empty")
9450 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: must have an output" "F - test-get-with-no-output: error message")
9451
9452 (check-ints-equal *(edx+4) 2 "F - test-get-with-no-output: exit status")
9453
9454 81 0/subop/add %esp 8/imm32
9455
9456 5d/pop-to-ebp
9457 c3/return
9458
9459 test-get-with-too-many-outputs:
9460
9461 55/push-ebp
9462 89/<- %ebp 4/r32/esp
9463
9464 (clear-stream _test-input-stream)
9465 (clear-stream $_test-input-buffered-file->buffer)
9466 (clear-stream _test-output-stream)
9467 (clear-stream $_test-output-buffered-file->buffer)
9468 (clear-stream _test-error-stream)
9469 (clear-stream $_test-error-buffered-file->buffer)
9470
9471 68/push 0/imm32
9472 68/push 0/imm32
9473 89/<- %edx 4/r32/esp
9474 (tailor-exit-descriptor %edx 0x10)
9475
9476 (write _test-input-stream "fn foo {\n")
9477 (write _test-input-stream " var a: t\n")
9478 (write _test-input-stream " var b: int\n")
9479 (write _test-input-stream " var c/eax: (addr int) <- copy 0\n")
9480 (write _test-input-stream " c, b <- get a, x\n")
9481 (write _test-input-stream "}\n")
9482 (write _test-input-stream "type t {\n")
9483 (write _test-input-stream " x: int\n")
9484 (write _test-input-stream "}\n")
9485
9486 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
9487
9488
9489 89/<- %edx 4/r32/esp
9490 (flush _test-output-buffered-file)
9491 (flush _test-error-buffered-file)
9492 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
9498
9499 (check-stream-equal _test-output-stream "" "F - test-get-with-too-many-outputs: output should be empty")
9500 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too many outputs (1 required)" "F - test-get-with-too-many-outputs: error message")
9501
9502 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-many-outputs: exit status")
9503
9504 81 0/subop/add %esp 8/imm32
9505
9506 5d/pop-to-ebp
9507 c3/return
9508
9509 test-convert-array-of-user-defined-types:
9510
9511 55/push-ebp
9512 89/<- %ebp 4/r32/esp
9513
9514 (clear-stream _test-input-stream)
9515 (clear-stream $_test-input-buffered-file->buffer)
9516 (clear-stream _test-output-stream)
9517 (clear-stream $_test-output-buffered-file->buffer)
9518
9519 (write _test-input-stream "type t {\n")
9520 (write _test-input-stream " x: int\n")
9521 (write _test-input-stream " y: int\n")
9522 (write _test-input-stream "}\n")
9523 (write _test-input-stream "fn foo {\n")
9524 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n")
9525 (write _test-input-stream " var idx/ecx: int <- copy 3\n")
9526 (write _test-input-stream " var x/eax: (addr t) <- index arr, idx\n")
9527 (write _test-input-stream "}\n")
9528
9529 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
9530 (flush _test-output-buffered-file)
9531 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
9537
9538 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-array-of-user-defined-types/0")
9539 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-array-of-user-defined-types/1")
9540 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-array-of-user-defined-types/2")
9541 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-array-of-user-defined-types/3")
9542 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-array-of-user-defined-types/4")
9543 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-array-of-user-defined-types/5")
9544 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-array-of-user-defined-types/6")
9545 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-array-of-user-defined-types/7")
9546 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-array-of-user-defined-types/8")
9547 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-array-of-user-defined-types/9")
9548 (check-next-stream-line-equal _test-output-stream " (__check-mu-array-bounds %ecx 0x00000008 *eax \"foo\" \"arr\")" "F - test-convert-array-of-user-defined-types/10")
9549 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000003 + 4) 0x00000000/r32" "F - test-convert-array-of-user-defined-types/11")
9550 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-array-of-user-defined-types/12")
9551 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-array-of-user-defined-types/13")
9552 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-array-of-user-defined-types/14")
9553 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-array-of-user-defined-types/15")
9554 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-array-of-user-defined-types/16")
9555 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-array-of-user-defined-types/17")
9556 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-array-of-user-defined-types/18")
9557 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-array-of-user-defined-types/19")
9558
9559 89/<- %esp 5/r32/ebp
9560 5d/pop-to-ebp
9561 c3/return
9562
9563 test-convert-length-of-array-of-user-defined-types-to-eax:
9564
9565 55/push-ebp
9566 89/<- %ebp 4/r32/esp
9567
9568 (clear-stream _test-input-stream)
9569 (clear-stream $_test-input-buffered-file->buffer)
9570 (clear-stream _test-output-stream)
9571 (clear-stream $_test-output-buffered-file->buffer)
9572
9573 (write _test-input-stream "type t {\n")
9574 (write _test-input-stream " x: int\n")
9575 (write _test-input-stream " y: int\n")
9576 (write _test-input-stream " z: int\n")
9577 (write _test-input-stream "}\n")
9578 (write _test-input-stream "fn foo {\n")
9579 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n")
9580 (write _test-input-stream " var x/eax: int <- length arr\n")
9581 (write _test-input-stream "}\n")
9582
9583 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
9584 (flush _test-output-buffered-file)
9585 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
9591
9592 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/0")
9593 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-eax/1")
9594 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/2")
9595 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/3")
9596 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-eax/4")
9597 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/5")
9598
9599 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-eax/6")
9600 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/7")
9601
9602 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/8")
9603 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/9")
9604 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/10")
9605 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/11")
9606 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/12")
9607 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/13")
9608 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/14")
9609 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/15")
9610
9611 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-eax/16")
9612
9613 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-eax/17")
9614 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/18")
9615 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-eax/19")
9616 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/20")
9617 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/21")
9618 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-eax/22")
9619
9620 89/<- %esp 5/r32/ebp
9621 5d/pop-to-ebp
9622 c3/return
9623
9624 test-convert-length-of-array-of-user-defined-types-to-ecx:
9625
9626 55/push-ebp
9627 89/<- %ebp 4/r32/esp
9628
9629 (clear-stream _test-input-stream)
9630 (clear-stream $_test-input-buffered-file->buffer)
9631 (clear-stream _test-output-stream)
9632 (clear-stream $_test-output-buffered-file->buffer)
9633
9634 (write _test-input-stream "type t {\n")
9635 (write _test-input-stream " x: int\n")
9636 (write _test-input-stream " y: int\n")
9637 (write _test-input-stream " z: int\n")
9638 (write _test-input-stream "}\n")
9639 (write _test-input-stream "fn foo {\n")
9640 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n")
9641 (write _test-input-stream " var x/ecx: int <- length arr\n")
9642 (write _test-input-stream "}\n")
9643
9644 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
9645 (flush _test-output-buffered-file)
9646 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
9652
9653 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/0")
9654 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/1")
9655 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/2")
9656 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/3")
9657 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/4")
9658 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/5")
9659
9660 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/6")
9661 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/7")
9662
9663 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/8")
9664
9665 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/9")
9666 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/10")
9667 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/11")
9668 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/12")
9669 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/13")
9670 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/14")
9671 (check-next-stream-line-equal _test-output-stream " 89/<- %ecx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/15")
9672 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/16")
9673 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/17")
9674
9675 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/18")
9676
9677 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/19")
9678
9679 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/20")
9680 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/21")
9681 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/22")
9682 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/23")
9683 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/24")
9684 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/25")
9685
9686 89/<- %esp 5/r32/ebp
9687 5d/pop-to-ebp
9688 c3/return
9689
9690 test-convert-length-of-array-of-user-defined-types-to-edx:
9691
9692 55/push-ebp
9693 89/<- %ebp 4/r32/esp
9694
9695 (clear-stream _test-input-stream)
9696 (clear-stream $_test-input-buffered-file->buffer)
9697 (clear-stream _test-output-stream)
9698 (clear-stream $_test-output-buffered-file->buffer)
9699
9700 (write _test-input-stream "type t {\n")
9701 (write _test-input-stream " x: int\n")
9702 (write _test-input-stream " y: int\n")
9703 (write _test-input-stream " z: int\n")
9704 (write _test-input-stream "}\n")
9705 (write _test-input-stream "fn foo {\n")
9706 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n")
9707 (write _test-input-stream " var x/edx: int <- length arr\n")
9708 (write _test-input-stream "}\n")
9709
9710 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
9711 (flush _test-output-buffered-file)
9712 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
9718
9719 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/0")
9720 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-edx/1")
9721 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/2")
9722 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/3")
9723 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-edx/4")
9724 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/5")
9725
9726 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/6")
9727 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/7")
9728
9729 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/8")
9730
9731 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/9")
9732 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/10")
9733 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/11")
9734 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/12")
9735 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/13")
9736 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/14")
9737 (check-next-stream-line-equal _test-output-stream " 89/<- %edx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/15")
9738 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/16")
9739 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/17")
9740
9741 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/18")
9742
9743 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/19")
9744
9745 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-edx/20")
9746 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/21")
9747 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-edx/22")
9748 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/23")
9749 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/24")
9750 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-edx/25")
9751
9752 89/<- %esp 5/r32/ebp
9753 5d/pop-to-ebp
9754 c3/return
9755
9756 test-convert-length-of-array-of-user-defined-types:
9757
9758 55/push-ebp
9759 89/<- %ebp 4/r32/esp
9760
9761 (clear-stream _test-input-stream)
9762 (clear-stream $_test-input-buffered-file->buffer)
9763 (clear-stream _test-output-stream)
9764 (clear-stream $_test-output-buffered-file->buffer)
9765
9766 (write _test-input-stream "type t {\n")
9767 (write _test-input-stream " x: int\n")
9768 (write _test-input-stream " y: int\n")
9769 (write _test-input-stream " z: int\n")
9770 (write _test-input-stream "}\n")
9771 (write _test-input-stream "fn foo {\n")
9772 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n")
9773 (write _test-input-stream " var x/ebx: int <- length arr\n")
9774 (write _test-input-stream "}\n")
9775
9776 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
9777 (flush _test-output-buffered-file)
9778 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
9784
9785 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types/0")
9786 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types/1")
9787 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types/2")
9788 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types/3")
9789 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types/4")
9790 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types/5")
9791 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types/6")
9792 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types/7")
9793 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ebx" "F - test-convert-length-of-array-of-user-defined-types/8")
9794 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types/9")
9795 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types/10")
9796 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types/11")
9797 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types/12")
9798 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types/13")
9799 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types/14")
9800 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types/15")
9801 (check-next-stream-line-equal _test-output-stream " 89/<- %ebx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types/16")
9802 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types/17")
9803 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types/18")
9804 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types/19")
9805 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ebx" "F - test-convert-length-of-array-of-user-defined-types/20")
9806 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types/21")
9807 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types/22")
9808 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types/23")
9809 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types/24")
9810 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types/25")
9811 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types/26")
9812 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types/27")
9813
9814 89/<- %esp 5/r32/ebp
9815 5d/pop-to-ebp
9816 c3/return
9817
9818 test-index-with-non-array-atom-base-type:
9819
9820 55/push-ebp
9821 89/<- %ebp 4/r32/esp
9822
9823 (clear-stream _test-input-stream)
9824 (clear-stream $_test-input-buffered-file->buffer)
9825 (clear-stream _test-output-stream)
9826 (clear-stream $_test-output-buffered-file->buffer)
9827 (clear-stream _test-error-stream)
9828 (clear-stream $_test-error-buffered-file->buffer)
9829
9830 68/push 0/imm32
9831 68/push 0/imm32
9832 89/<- %edx 4/r32/esp
9833 (tailor-exit-descriptor %edx 0x10)
9834
9835 (write _test-input-stream "fn foo {\n")
9836 (write _test-input-stream " var a: int\n")
9837 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n")
9838 (write _test-input-stream "}\n")
9839
9840 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
9841
9842
9843 89/<- %edx 4/r32/esp
9844 (flush _test-output-buffered-file)
9845 (flush _test-error-buffered-file)
9846 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
9852
9853 (check-stream-equal _test-output-stream "" "F - test-index-with-non-array-atom-base-type: output should be empty")
9854 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is not an array" "F - test-index-with-non-array-atom-base-type: error message")
9855
9856 (check-ints-equal *(edx+4) 2 "F - test-index-with-non-array-atom-base-type: exit status")
9857
9858 81 0/subop/add %esp 8/imm32
9859
9860 5d/pop-to-ebp
9861 c3/return
9862
9863 test-index-with-non-array-compound-base-type:
9864
9865 55/push-ebp
9866 89/<- %ebp 4/r32/esp
9867
9868 (clear-stream _test-input-stream)
9869 (clear-stream $_test-input-buffered-file->buffer)
9870 (clear-stream _test-output-stream)
9871 (clear-stream $_test-output-buffered-file->buffer)
9872 (clear-stream _test-error-stream)
9873 (clear-stream $_test-error-buffered-file->buffer)
9874
9875 68/push 0/imm32
9876 68/push 0/imm32
9877 89/<- %edx 4/r32/esp
9878 (tailor-exit-descriptor %edx 0x10)
9879
9880 (write _test-input-stream "fn foo {\n")
9881 (write _test-input-stream " var a: (handle int)\n")
9882 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n")
9883 (write _test-input-stream "}\n")
9884
9885 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
9886
9887
9888 89/<- %edx 4/r32/esp
9889 (flush _test-output-buffered-file)
9890 (flush _test-error-buffered-file)
9891 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
9897
9898 (check-stream-equal _test-output-stream "" "F - test-index-with-non-array-compound-base-type: output should be empty")
9899 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is not an array" "F - test-index-with-non-array-compound-base-type: error message")
9900
9901 (check-ints-equal *(edx+4) 2 "F - test-index-with-non-array-compound-base-type: exit status")
9902
9903 81 0/subop/add %esp 8/imm32
9904
9905 5d/pop-to-ebp
9906 c3/return
9907
9908 test-index-with-non-array-compound-base-type-2:
9909
9910 55/push-ebp
9911 89/<- %ebp 4/r32/esp
9912
9913 (clear-stream _test-input-stream)
9914 (clear-stream $_test-input-buffered-file->buffer)
9915 (clear-stream _test-output-stream)
9916 (clear-stream $_test-output-buffered-file->buffer)
9917 (clear-stream _test-error-stream)
9918 (clear-stream $_test-error-buffered-file->buffer)
9919
9920 68/push 0/imm32
9921 68/push 0/imm32
9922 89/<- %edx 4/r32/esp
9923 (tailor-exit-descriptor %edx 0x10)
9924
9925 (write _test-input-stream "fn foo {\n")
9926 (write _test-input-stream " var a: (addr int)\n")
9927 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n")
9928 (write _test-input-stream "}\n")
9929
9930 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
9931
9932
9933 89/<- %edx 4/r32/esp
9934 (flush _test-output-buffered-file)
9935 (flush _test-error-buffered-file)
9936 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
9942
9943 (check-stream-equal _test-output-stream "" "F - test-index-with-non-array-compound-base-type-2: output should be empty")
9944 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is not an array" "F - test-index-with-non-array-compound-base-type-2: error message")
9945
9946 (check-ints-equal *(edx+4) 2 "F - test-index-with-non-array-compound-base-type-2: exit status")
9947
9948 81 0/subop/add %esp 8/imm32
9949
9950 5d/pop-to-ebp
9951 c3/return
9952
9953 test-index-with-array-atom-base-type:
9954
9955 55/push-ebp
9956 89/<- %ebp 4/r32/esp
9957
9958 (clear-stream _test-input-stream)
9959 (clear-stream $_test-input-buffered-file->buffer)
9960 (clear-stream _test-output-stream)
9961 (clear-stream $_test-output-buffered-file->buffer)
9962 (clear-stream _test-error-stream)
9963 (clear-stream $_test-error-buffered-file->buffer)
9964
9965 68/push 0/imm32
9966 68/push 0/imm32
9967 89/<- %edx 4/r32/esp
9968 (tailor-exit-descriptor %edx 0x10)
9969
9970 (write _test-input-stream "fn foo {\n")
9971 (write _test-input-stream " var a: array\n")
9972 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n")
9973 (write _test-input-stream "}\n")
9974
9975 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
9976
9977
9978 89/<- %edx 4/r32/esp
9979 (flush _test-output-buffered-file)
9980 (flush _test-error-buffered-file)
9981 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
9987
9988 (check-stream-equal _test-output-stream "" "F - test-index-with-array-atom-base-type: output should be empty")
9989 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: array 'a' must specify the type of its elements" "F - test-index-with-array-atom-base-type: error message")
9990
9991 (check-ints-equal *(edx+4) 2 "F - test-index-with-array-atom-base-type: exit status")
9992
9993 81 0/subop/add %esp 8/imm32
9994
9995 5d/pop-to-ebp
9996 c3/return
9997
9998 test-index-with-addr-base-on-stack:
9999
10000 55/push-ebp
10001 89/<- %ebp 4/r32/esp
10002
10003 (clear-stream _test-input-stream)
10004 (clear-stream $_test-input-buffered-file->buffer)
10005 (clear-stream _test-output-stream)
10006 (clear-stream $_test-output-buffered-file->buffer)
10007 (clear-stream _test-error-stream)
10008 (clear-stream $_test-error-buffered-file->buffer)
10009
10010 68/push 0/imm32
10011 68/push 0/imm32
10012 89/<- %edx 4/r32/esp
10013 (tailor-exit-descriptor %edx 0x10)
10014
10015 (write _test-input-stream "fn foo {\n")
10016 (write _test-input-stream " var a: (addr array int)\n")
10017 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n")
10018 (write _test-input-stream "}\n")
10019
10020 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10021
10022
10023 89/<- %edx 4/r32/esp
10024 (flush _test-output-buffered-file)
10025 (flush _test-error-buffered-file)
10026 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10032
10033 (check-stream-equal _test-output-stream "" "F - test-index-with-addr-base-on-stack: output should be empty")
10034 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is an addr to an array, and so must live in a register" "F - test-index-with-addr-base-on-stack: error message")
10035
10036 (check-ints-equal *(edx+4) 2 "F - test-index-with-addr-base-on-stack: exit status")
10037
10038 81 0/subop/add %esp 8/imm32
10039
10040 5d/pop-to-ebp
10041 c3/return
10042
10043 test-index-with-wrong-index-type:
10044
10045 55/push-ebp
10046 89/<- %ebp 4/r32/esp
10047
10048 (clear-stream _test-input-stream)
10049 (clear-stream $_test-input-buffered-file->buffer)
10050 (clear-stream _test-output-stream)
10051 (clear-stream $_test-output-buffered-file->buffer)
10052 (clear-stream _test-error-stream)
10053 (clear-stream $_test-error-buffered-file->buffer)
10054
10055 68/push 0/imm32
10056 68/push 0/imm32
10057 89/<- %edx 4/r32/esp
10058 (tailor-exit-descriptor %edx 0x10)
10059
10060 (write _test-input-stream "fn foo {\n")
10061 (write _test-input-stream " var a/eax: (addr array int) <- copy 0\n")
10062 (write _test-input-stream " var b: boolean\n")
10063 (write _test-input-stream " var c/ecx: (addr int) <- index a, b\n")
10064 (write _test-input-stream "}\n")
10065
10066 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10067
10068
10069 89/<- %edx 4/r32/esp
10070 (flush _test-output-buffered-file)
10071 (flush _test-error-buffered-file)
10072 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10078
10079 (check-stream-equal _test-output-stream "" "F - test-index-with-wrong-index-type: output should be empty")
10080 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: second argument 'b' must be an int or offset" "F - test-index-with-wrong-index-type: error message")
10081
10082 (check-ints-equal *(edx+4) 2 "F - test-index-with-wrong-index-type: exit status")
10083
10084 81 0/subop/add %esp 8/imm32
10085
10086 5d/pop-to-ebp
10087 c3/return
10088
10089 test-index-with-offset-atom-index-type:
10090
10091 55/push-ebp
10092 89/<- %ebp 4/r32/esp
10093
10094 (clear-stream _test-input-stream)
10095 (clear-stream $_test-input-buffered-file->buffer)
10096 (clear-stream _test-output-stream)
10097 (clear-stream $_test-output-buffered-file->buffer)
10098 (clear-stream _test-error-stream)
10099 (clear-stream $_test-error-buffered-file->buffer)
10100
10101 68/push 0/imm32
10102 68/push 0/imm32
10103 89/<- %edx 4/r32/esp
10104 (tailor-exit-descriptor %edx 0x10)
10105
10106 (write _test-input-stream "fn foo {\n")
10107 (write _test-input-stream " var a/eax: (addr array int) <- copy 0\n")
10108 (write _test-input-stream " var b: offset\n")
10109 (write _test-input-stream " var c/ecx: (addr int) <- index a, b\n")
10110 (write _test-input-stream "}\n")
10111
10112 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10113
10114
10115 89/<- %edx 4/r32/esp
10116 (flush _test-output-buffered-file)
10117 (flush _test-error-buffered-file)
10118 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10124
10125 (check-stream-equal _test-output-stream "" "F - test-index-with-offset-atom-index-type: output should be empty")
10126 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: offset 'b' must specify the type of array elements" "F - test-index-with-offset-atom-index-type: error message")
10127
10128 (check-ints-equal *(edx+4) 2 "F - test-index-with-offset-atom-index-type: exit status")
10129
10130 81 0/subop/add %esp 8/imm32
10131
10132 5d/pop-to-ebp
10133 c3/return
10134
10135 test-index-with-offset-on-stack:
10136
10137 55/push-ebp
10138 89/<- %ebp 4/r32/esp
10139
10140 (clear-stream _test-input-stream)
10141 (clear-stream $_test-input-buffered-file->buffer)
10142 (clear-stream _test-output-stream)
10143 (clear-stream $_test-output-buffered-file->buffer)
10144 (clear-stream _test-error-stream)
10145 (clear-stream $_test-error-buffered-file->buffer)
10146
10147 68/push 0/imm32
10148 68/push 0/imm32
10149 89/<- %edx 4/r32/esp
10150 (tailor-exit-descriptor %edx 0x10)
10151
10152 (write _test-input-stream "fn foo {\n")
10153 (write _test-input-stream " var a/eax: (addr array int) <- copy 0\n")
10154 (write _test-input-stream " var b: int\n")
10155 (write _test-input-stream " var c/ecx: (addr int) <- index a, b\n")
10156 (write _test-input-stream "}\n")
10157
10158 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10159
10160
10161 89/<- %edx 4/r32/esp
10162 (flush _test-output-buffered-file)
10163 (flush _test-error-buffered-file)
10164 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10170
10171 (check-stream-equal _test-output-stream "" "F - test-index-with-offset-on-stack: output should be empty")
10172 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: second argument 'b' must be in a register" "F - test-index-with-offset-on-stack: error message")
10173
10174 (check-ints-equal *(edx+4) 2 "F - test-index-with-offset-on-stack: exit status")
10175
10176 81 0/subop/add %esp 8/imm32
10177
10178 5d/pop-to-ebp
10179 c3/return
10180
10181 test-index-needs-offset-type:
10182
10183 55/push-ebp
10184 89/<- %ebp 4/r32/esp
10185
10186 (clear-stream _test-input-stream)
10187 (clear-stream $_test-input-buffered-file->buffer)
10188 (clear-stream _test-output-stream)
10189 (clear-stream $_test-output-buffered-file->buffer)
10190 (clear-stream _test-error-stream)
10191 (clear-stream $_test-error-buffered-file->buffer)
10192
10193 68/push 0/imm32
10194 68/push 0/imm32
10195 89/<- %edx 4/r32/esp
10196 (tailor-exit-descriptor %edx 0x10)
10197
10198 (write _test-input-stream "fn foo {\n")
10199 (write _test-input-stream " var a/eax: (addr array t) <- copy 0\n")
10200 (write _test-input-stream " var b/ebx: int <- copy 0\n")
10201 (write _test-input-stream " var c/ecx: (addr int) <- index a, b\n")
10202 (write _test-input-stream "}\n")
10203 (write _test-input-stream "type t {\n")
10204 (write _test-input-stream " x: int\n")
10205 (write _test-input-stream " y: int\n")
10206 (write _test-input-stream " z: int\n")
10207 (write _test-input-stream "}\n")
10208
10209 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10210
10211
10212 89/<- %edx 4/r32/esp
10213 (flush _test-output-buffered-file)
10214 (flush _test-error-buffered-file)
10215 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10221
10222 (check-stream-equal _test-output-stream "" "F - test-index-needs-offset-type: output should be empty")
10223 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: cannot take an int for array 'a'; create an offset instead. See mu.md for details." "F - test-index-needs-offset-type: error message")
10224
10225 (check-ints-equal *(edx+4) 2 "F - test-index-needs-offset-type: exit status")
10226
10227 81 0/subop/add %esp 8/imm32
10228
10229 5d/pop-to-ebp
10230 c3/return
10231
10232 test-index-with-output-not-address:
10233
10234 55/push-ebp
10235 89/<- %ebp 4/r32/esp
10236
10237 (clear-stream _test-input-stream)
10238 (clear-stream $_test-input-buffered-file->buffer)
10239 (clear-stream _test-output-stream)
10240 (clear-stream $_test-output-buffered-file->buffer)
10241 (clear-stream _test-error-stream)
10242 (clear-stream $_test-error-buffered-file->buffer)
10243
10244 68/push 0/imm32
10245 68/push 0/imm32
10246 89/<- %edx 4/r32/esp
10247 (tailor-exit-descriptor %edx 0x10)
10248
10249 (write _test-input-stream "fn foo {\n")
10250 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n")
10251 (write _test-input-stream " var o/edi: int <- index a, 0\n")
10252 (write _test-input-stream "}\n")
10253
10254 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10255
10256
10257 89/<- %edx 4/r32/esp
10258 (flush _test-output-buffered-file)
10259 (flush _test-error-buffered-file)
10260 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10266
10267 (check-stream-equal _test-output-stream "" "F - test-index-with-output-not-address: output should be empty")
10268 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' must be an addr" "F - test-index-with-output-not-address: error message")
10269
10270 (check-ints-equal *(edx+4) 2 "F - test-index-with-output-not-address: exit status")
10271
10272 81 0/subop/add %esp 8/imm32
10273
10274 5d/pop-to-ebp
10275 c3/return
10276
10277 test-index-with-output-not-address-2:
10278
10279 55/push-ebp
10280 89/<- %ebp 4/r32/esp
10281
10282 (clear-stream _test-input-stream)
10283 (clear-stream $_test-input-buffered-file->buffer)
10284 (clear-stream _test-output-stream)
10285 (clear-stream $_test-output-buffered-file->buffer)
10286 (clear-stream _test-error-stream)
10287 (clear-stream $_test-error-buffered-file->buffer)
10288
10289 68/push 0/imm32
10290 68/push 0/imm32
10291 89/<- %edx 4/r32/esp
10292 (tailor-exit-descriptor %edx 0x10)
10293
10294 (write _test-input-stream "fn foo {\n")
10295 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n")
10296 (write _test-input-stream " var o/edi: (int) <- index a, 0\n")
10297 (write _test-input-stream "}\n")
10298
10299 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10300
10301
10302 89/<- %edx 4/r32/esp
10303 (flush _test-output-buffered-file)
10304 (flush _test-error-buffered-file)
10305 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10311
10312 (check-stream-equal _test-output-stream "" "F - test-index-with-output-not-address-2: output should be empty")
10313 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' must be an addr" "F - test-index-with-output-not-address-2: error message")
10314
10315 (check-ints-equal *(edx+4) 2 "F - test-index-with-output-not-address-2: exit status")
10316
10317 81 0/subop/add %esp 8/imm32
10318
10319 5d/pop-to-ebp
10320 c3/return
10321
10322 test-index-with-wrong-output-type:
10323
10324 55/push-ebp
10325 89/<- %ebp 4/r32/esp
10326
10327 (clear-stream _test-input-stream)
10328 (clear-stream $_test-input-buffered-file->buffer)
10329 (clear-stream _test-output-stream)
10330 (clear-stream $_test-output-buffered-file->buffer)
10331 (clear-stream _test-error-stream)
10332 (clear-stream $_test-error-buffered-file->buffer)
10333
10334 68/push 0/imm32
10335 68/push 0/imm32
10336 89/<- %edx 4/r32/esp
10337 (tailor-exit-descriptor %edx 0x10)
10338
10339 (write _test-input-stream "fn foo {\n")
10340 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n")
10341 (write _test-input-stream " var o/edi: (addr int) <- index a, 0\n")
10342 (write _test-input-stream "}\n")
10343
10344 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10345
10346
10347 89/<- %edx 4/r32/esp
10348 (flush _test-output-buffered-file)
10349 (flush _test-error-buffered-file)
10350 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10356
10357 (check-stream-equal _test-output-stream "" "F - test-index-with-wrong-output-type: output should be empty")
10358 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' does not have the right type" "F - test-index-with-wrong-output-type: error message")
10359
10360 (check-ints-equal *(edx+4) 2 "F - test-index-with-wrong-output-type: exit status")
10361
10362 81 0/subop/add %esp 8/imm32
10363
10364 5d/pop-to-ebp
10365 c3/return
10366
10367 test-index-with-wrong-output-compound-type:
10368
10369 55/push-ebp
10370 89/<- %ebp 4/r32/esp
10371
10372 (clear-stream _test-input-stream)
10373 (clear-stream $_test-input-buffered-file->buffer)
10374 (clear-stream _test-output-stream)
10375 (clear-stream $_test-output-buffered-file->buffer)
10376 (clear-stream _test-error-stream)
10377 (clear-stream $_test-error-buffered-file->buffer)
10378
10379 68/push 0/imm32
10380 68/push 0/imm32
10381 89/<- %edx 4/r32/esp
10382 (tailor-exit-descriptor %edx 0x10)
10383
10384 (write _test-input-stream "fn foo {\n")
10385 (write _test-input-stream " var a/ebx: (addr array handle boolean) <- copy 0\n")
10386 (write _test-input-stream " var o/edi: (addr handle int) <- index a, 0\n")
10387 (write _test-input-stream "}\n")
10388
10389 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10390
10391
10392 89/<- %edx 4/r32/esp
10393 (flush _test-output-buffered-file)
10394 (flush _test-error-buffered-file)
10395 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10401
10402 (check-stream-equal _test-output-stream "" "F - test-index-with-wrong-output-compound-type: output should be empty")
10403 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' does not have the right type" "F - test-index-with-wrong-output-compound-type: error message")
10404
10405 (check-ints-equal *(edx+4) 2 "F - test-index-with-wrong-output-compound-type: exit status")
10406
10407 81 0/subop/add %esp 8/imm32
10408
10409 5d/pop-to-ebp
10410 c3/return
10411
10412 test-index-with-no-inouts:
10413
10414 55/push-ebp
10415 89/<- %ebp 4/r32/esp
10416
10417 (clear-stream _test-input-stream)
10418 (clear-stream $_test-input-buffered-file->buffer)
10419 (clear-stream _test-output-stream)
10420 (clear-stream $_test-output-buffered-file->buffer)
10421 (clear-stream _test-error-stream)
10422 (clear-stream $_test-error-buffered-file->buffer)
10423
10424 68/push 0/imm32
10425 68/push 0/imm32
10426 89/<- %edx 4/r32/esp
10427 (tailor-exit-descriptor %edx 0x10)
10428
10429 (write _test-input-stream "fn foo {\n")
10430 (write _test-input-stream " var c/ecx: (addr int) <- index\n")
10431 (write _test-input-stream "}\n")
10432
10433 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10434
10435
10436 89/<- %edx 4/r32/esp
10437 (flush _test-output-buffered-file)
10438 (flush _test-error-buffered-file)
10439 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10445
10446 (check-stream-equal _test-output-stream "" "F - test-index-with-no-inouts: output should be empty")
10447 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too few inouts (2 required)" "F - test-index-with-no-inouts: error message")
10448
10449 (check-ints-equal *(edx+4) 2 "F - test-index-with-no-inouts: exit status")
10450
10451 81 0/subop/add %esp 8/imm32
10452
10453 5d/pop-to-ebp
10454 c3/return
10455
10456 test-index-with-too-few-inouts:
10457
10458 55/push-ebp
10459 89/<- %ebp 4/r32/esp
10460
10461 (clear-stream _test-input-stream)
10462 (clear-stream $_test-input-buffered-file->buffer)
10463 (clear-stream _test-output-stream)
10464 (clear-stream $_test-output-buffered-file->buffer)
10465 (clear-stream _test-error-stream)
10466 (clear-stream $_test-error-buffered-file->buffer)
10467
10468 68/push 0/imm32
10469 68/push 0/imm32
10470 89/<- %edx 4/r32/esp
10471 (tailor-exit-descriptor %edx 0x10)
10472
10473 (write _test-input-stream "fn foo {\n")
10474 (write _test-input-stream " var a: (array int 3)\n")
10475 (write _test-input-stream " var c/ecx: (addr int) <- index a\n")
10476 (write _test-input-stream "}\n")
10477
10478 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10479
10480
10481 89/<- %edx 4/r32/esp
10482 (flush _test-output-buffered-file)
10483 (flush _test-error-buffered-file)
10484 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10490
10491 (check-stream-equal _test-output-stream "" "F - test-index-with-too-few-inouts: output should be empty")
10492 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too few inouts (2 required)" "F - test-index-with-too-few-inouts: error message")
10493
10494 (check-ints-equal *(edx+4) 2 "F - test-index-with-too-few-inouts: exit status")
10495
10496 81 0/subop/add %esp 8/imm32
10497
10498 5d/pop-to-ebp
10499 c3/return
10500
10501 test-index-with-too-many-inouts:
10502
10503 55/push-ebp
10504 89/<- %ebp 4/r32/esp
10505
10506 (clear-stream _test-input-stream)
10507 (clear-stream $_test-input-buffered-file->buffer)
10508 (clear-stream _test-output-stream)
10509 (clear-stream $_test-output-buffered-file->buffer)
10510 (clear-stream _test-error-stream)
10511 (clear-stream $_test-error-buffered-file->buffer)
10512
10513 68/push 0/imm32
10514 68/push 0/imm32
10515 89/<- %edx 4/r32/esp
10516 (tailor-exit-descriptor %edx 0x10)
10517
10518 (write _test-input-stream "fn foo {\n")
10519 (write _test-input-stream " var a: (array int 3)\n")
10520 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0, 0\n")
10521 (write _test-input-stream "}\n")
10522
10523 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10524
10525
10526 89/<- %edx 4/r32/esp
10527 (flush _test-output-buffered-file)
10528 (flush _test-error-buffered-file)
10529 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10535
10536 (check-stream-equal _test-output-stream "" "F - test-index-with-too-many-inouts: output should be empty")
10537 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too many inouts (2 required)" "F - test-index-with-too-many-inouts: error message")
10538
10539 (check-ints-equal *(edx+4) 2 "F - test-index-with-too-many-inouts: exit status")
10540
10541 81 0/subop/add %esp 8/imm32
10542
10543 5d/pop-to-ebp
10544 c3/return
10545
10546 test-index-with-no-output:
10547
10548 55/push-ebp
10549 89/<- %ebp 4/r32/esp
10550
10551 (clear-stream _test-input-stream)
10552 (clear-stream $_test-input-buffered-file->buffer)
10553 (clear-stream _test-output-stream)
10554 (clear-stream $_test-output-buffered-file->buffer)
10555 (clear-stream _test-error-stream)
10556 (clear-stream $_test-error-buffered-file->buffer)
10557
10558 68/push 0/imm32
10559 68/push 0/imm32
10560 89/<- %edx 4/r32/esp
10561 (tailor-exit-descriptor %edx 0x10)
10562
10563 (write _test-input-stream "fn foo {\n")
10564 (write _test-input-stream " var a: (array int 3)\n")
10565 (write _test-input-stream " index a, 0\n")
10566 (write _test-input-stream "}\n")
10567
10568 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10569
10570
10571 89/<- %edx 4/r32/esp
10572 (flush _test-output-buffered-file)
10573 (flush _test-error-buffered-file)
10574 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10580
10581 (check-stream-equal _test-output-stream "" "F - test-index-with-no-output: output should be empty")
10582 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: must have an output" "F - test-index-with-no-output: error message")
10583
10584 (check-ints-equal *(edx+4) 2 "F - test-index-with-no-output: exit status")
10585
10586 81 0/subop/add %esp 8/imm32
10587
10588 5d/pop-to-ebp
10589 c3/return
10590
10591 test-index-with-too-many-outputs:
10592
10593 55/push-ebp
10594 89/<- %ebp 4/r32/esp
10595
10596 (clear-stream _test-input-stream)
10597 (clear-stream $_test-input-buffered-file->buffer)
10598 (clear-stream _test-output-stream)
10599 (clear-stream $_test-output-buffered-file->buffer)
10600 (clear-stream _test-error-stream)
10601 (clear-stream $_test-error-buffered-file->buffer)
10602
10603 68/push 0/imm32
10604 68/push 0/imm32
10605 89/<- %edx 4/r32/esp
10606 (tailor-exit-descriptor %edx 0x10)
10607
10608 (write _test-input-stream "fn foo {\n")
10609 (write _test-input-stream " var a: (array int 3)\n")
10610 (write _test-input-stream " var b/eax: (addr int) <- copy 0\n")
10611 (write _test-input-stream " var c/ecx: (addr int) <- copy 0\n")
10612 (write _test-input-stream " b, c <- index a, 0\n")
10613 (write _test-input-stream "}\n")
10614
10615 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10616
10617
10618 89/<- %edx 4/r32/esp
10619 (flush _test-output-buffered-file)
10620 (flush _test-error-buffered-file)
10621 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10627
10628 (check-stream-equal _test-output-stream "" "F - test-index-with-too-many-outputs: output should be empty")
10629 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too many outputs (1 required)" "F - test-index-with-too-many-outputs: error message")
10630
10631 (check-ints-equal *(edx+4) 2 "F - test-index-with-too-many-outputs: exit status")
10632
10633 81 0/subop/add %esp 8/imm32
10634
10635 5d/pop-to-ebp
10636 c3/return
10637
10638 test-compute-offset-with-non-array-atom-base-type:
10639
10640 55/push-ebp
10641 89/<- %ebp 4/r32/esp
10642
10643 (clear-stream _test-input-stream)
10644 (clear-stream $_test-input-buffered-file->buffer)
10645 (clear-stream _test-output-stream)
10646 (clear-stream $_test-output-buffered-file->buffer)
10647 (clear-stream _test-error-stream)
10648 (clear-stream $_test-error-buffered-file->buffer)
10649
10650 68/push 0/imm32
10651 68/push 0/imm32
10652 89/<- %edx 4/r32/esp
10653 (tailor-exit-descriptor %edx 0x10)
10654
10655 (write _test-input-stream "fn foo {\n")
10656 (write _test-input-stream " var a: int\n")
10657 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0\n")
10658 (write _test-input-stream "}\n")
10659
10660 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10661
10662
10663 89/<- %edx 4/r32/esp
10664 (flush _test-output-buffered-file)
10665 (flush _test-error-buffered-file)
10666 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10672
10673 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-non-array-atom-base-type: output should be empty")
10674 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: var 'a' is not an array" "F - test-compute-offset-with-non-array-atom-base-type: error message")
10675
10676 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-non-array-atom-base-type: exit status")
10677
10678 81 0/subop/add %esp 8/imm32
10679
10680 5d/pop-to-ebp
10681 c3/return
10682
10683 test-compute-offset-with-non-array-compound-base-type:
10684
10685 55/push-ebp
10686 89/<- %ebp 4/r32/esp
10687
10688 (clear-stream _test-input-stream)
10689 (clear-stream $_test-input-buffered-file->buffer)
10690 (clear-stream _test-output-stream)
10691 (clear-stream $_test-output-buffered-file->buffer)
10692 (clear-stream _test-error-stream)
10693 (clear-stream $_test-error-buffered-file->buffer)
10694
10695 68/push 0/imm32
10696 68/push 0/imm32
10697 89/<- %edx 4/r32/esp
10698 (tailor-exit-descriptor %edx 0x10)
10699
10700 (write _test-input-stream "fn foo {\n")
10701 (write _test-input-stream " var a: (handle int)\n")
10702 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0\n")
10703 (write _test-input-stream "}\n")
10704
10705 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10706
10707
10708 89/<- %edx 4/r32/esp
10709 (flush _test-output-buffered-file)
10710 (flush _test-error-buffered-file)
10711 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10717
10718 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-non-array-compound-base-type: output should be empty")
10719 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: var 'a' is not an array" "F - test-compute-offset-with-non-array-compound-base-type: error message")
10720
10721 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-non-array-compound-base-type: exit status")
10722
10723 81 0/subop/add %esp 8/imm32
10724
10725 5d/pop-to-ebp
10726 c3/return
10727
10728 test-compute-offset-with-non-array-compound-base-type-2:
10729
10730 55/push-ebp
10731 89/<- %ebp 4/r32/esp
10732
10733 (clear-stream _test-input-stream)
10734 (clear-stream $_test-input-buffered-file->buffer)
10735 (clear-stream _test-output-stream)
10736 (clear-stream $_test-output-buffered-file->buffer)
10737 (clear-stream _test-error-stream)
10738 (clear-stream $_test-error-buffered-file->buffer)
10739
10740 68/push 0/imm32
10741 68/push 0/imm32
10742 89/<- %edx 4/r32/esp
10743 (tailor-exit-descriptor %edx 0x10)
10744
10745 (write _test-input-stream "fn foo {\n")
10746 (write _test-input-stream " var a: (addr int)\n")
10747 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0\n")
10748 (write _test-input-stream "}\n")
10749
10750 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10751
10752
10753 89/<- %edx 4/r32/esp
10754 (flush _test-output-buffered-file)
10755 (flush _test-error-buffered-file)
10756 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10762
10763 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-non-array-compound-base-type-2: output should be empty")
10764 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: var 'a' is not an array" "F - test-compute-offset-with-non-array-compound-base-type-2: error message")
10765
10766 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-non-array-compound-base-type-2: exit status")
10767
10768 81 0/subop/add %esp 8/imm32
10769
10770 5d/pop-to-ebp
10771 c3/return
10772
10773 test-compute-offset-with-array-atom-base-type:
10774
10775 55/push-ebp
10776 89/<- %ebp 4/r32/esp
10777
10778 (clear-stream _test-input-stream)
10779 (clear-stream $_test-input-buffered-file->buffer)
10780 (clear-stream _test-output-stream)
10781 (clear-stream $_test-output-buffered-file->buffer)
10782 (clear-stream _test-error-stream)
10783 (clear-stream $_test-error-buffered-file->buffer)
10784
10785 68/push 0/imm32
10786 68/push 0/imm32
10787 89/<- %edx 4/r32/esp
10788 (tailor-exit-descriptor %edx 0x10)
10789
10790 (write _test-input-stream "fn foo {\n")
10791 (write _test-input-stream " var a: array\n")
10792 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0\n")
10793 (write _test-input-stream "}\n")
10794
10795 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10796
10797
10798 89/<- %edx 4/r32/esp
10799 (flush _test-output-buffered-file)
10800 (flush _test-error-buffered-file)
10801 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10807
10808 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-array-atom-base-type: output should be empty")
10809 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: array 'a' must specify the type of its elements" "F - test-compute-offset-with-array-atom-base-type: error message")
10810
10811 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-array-atom-base-type: exit status")
10812
10813 81 0/subop/add %esp 8/imm32
10814
10815 5d/pop-to-ebp
10816 c3/return
10817
10818 test-compute-offset-with-wrong-index-type:
10819
10820 55/push-ebp
10821 89/<- %ebp 4/r32/esp
10822
10823 (clear-stream _test-input-stream)
10824 (clear-stream $_test-input-buffered-file->buffer)
10825 (clear-stream _test-output-stream)
10826 (clear-stream $_test-output-buffered-file->buffer)
10827 (clear-stream _test-error-stream)
10828 (clear-stream $_test-error-buffered-file->buffer)
10829
10830 68/push 0/imm32
10831 68/push 0/imm32
10832 89/<- %edx 4/r32/esp
10833 (tailor-exit-descriptor %edx 0x10)
10834
10835 (write _test-input-stream "fn foo {\n")
10836 (write _test-input-stream " var a/eax: (addr array int) <- copy 0\n")
10837 (write _test-input-stream " var b: boolean\n")
10838 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, b\n")
10839 (write _test-input-stream "}\n")
10840
10841 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10842
10843
10844 89/<- %edx 4/r32/esp
10845 (flush _test-output-buffered-file)
10846 (flush _test-error-buffered-file)
10847 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10853
10854 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-wrong-index-type: output should be empty")
10855 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: second argument 'b' must be an int" "F - test-compute-offset-with-wrong-index-type: error message")
10856
10857 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-wrong-index-type: exit status")
10858
10859 81 0/subop/add %esp 8/imm32
10860
10861 5d/pop-to-ebp
10862 c3/return
10863
10864 test-compute-offset-with-output-not-offset:
10865
10866 55/push-ebp
10867 89/<- %ebp 4/r32/esp
10868
10869 (clear-stream _test-input-stream)
10870 (clear-stream $_test-input-buffered-file->buffer)
10871 (clear-stream _test-output-stream)
10872 (clear-stream $_test-output-buffered-file->buffer)
10873 (clear-stream _test-error-stream)
10874 (clear-stream $_test-error-buffered-file->buffer)
10875
10876 68/push 0/imm32
10877 68/push 0/imm32
10878 89/<- %edx 4/r32/esp
10879 (tailor-exit-descriptor %edx 0x10)
10880
10881 (write _test-input-stream "fn foo {\n")
10882 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n")
10883 (write _test-input-stream " var o/edi: int <- compute-offset a, 0\n")
10884 (write _test-input-stream "}\n")
10885
10886 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10887
10888
10889 89/<- %edx 4/r32/esp
10890 (flush _test-output-buffered-file)
10891 (flush _test-error-buffered-file)
10892 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10898
10899 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-output-not-offset: output should be empty")
10900 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: output 'o' must be an offset" "F - test-compute-offset-with-output-not-offset: error message")
10901
10902 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-output-not-offset: exit status")
10903
10904 81 0/subop/add %esp 8/imm32
10905
10906 5d/pop-to-ebp
10907 c3/return
10908
10909 test-compute-offset-with-output-not-address-2:
10910
10911 55/push-ebp
10912 89/<- %ebp 4/r32/esp
10913
10914 (clear-stream _test-input-stream)
10915 (clear-stream $_test-input-buffered-file->buffer)
10916 (clear-stream _test-output-stream)
10917 (clear-stream $_test-output-buffered-file->buffer)
10918 (clear-stream _test-error-stream)
10919 (clear-stream $_test-error-buffered-file->buffer)
10920
10921 68/push 0/imm32
10922 68/push 0/imm32
10923 89/<- %edx 4/r32/esp
10924 (tailor-exit-descriptor %edx 0x10)
10925
10926 (write _test-input-stream "fn foo {\n")
10927 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n")
10928 (write _test-input-stream " var o/edi: (int) <- compute-offset a, 0\n")
10929 (write _test-input-stream "}\n")
10930
10931 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10932
10933
10934 89/<- %edx 4/r32/esp
10935 (flush _test-output-buffered-file)
10936 (flush _test-error-buffered-file)
10937 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10943
10944 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-output-not-address-2: output should be empty")
10945 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: output 'o' must be an offset" "F - test-compute-offset-with-output-not-address-2: error message")
10946
10947 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-output-not-address-2: exit status")
10948
10949 81 0/subop/add %esp 8/imm32
10950
10951 5d/pop-to-ebp
10952 c3/return
10953
10954 test-compute-offset-with-wrong-output-type:
10955
10956 55/push-ebp
10957 89/<- %ebp 4/r32/esp
10958
10959 (clear-stream _test-input-stream)
10960 (clear-stream $_test-input-buffered-file->buffer)
10961 (clear-stream _test-output-stream)
10962 (clear-stream $_test-output-buffered-file->buffer)
10963 (clear-stream _test-error-stream)
10964 (clear-stream $_test-error-buffered-file->buffer)
10965
10966 68/push 0/imm32
10967 68/push 0/imm32
10968 89/<- %edx 4/r32/esp
10969 (tailor-exit-descriptor %edx 0x10)
10970
10971 (write _test-input-stream "fn foo {\n")
10972 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n")
10973 (write _test-input-stream " var o/edi: (offset int) <- compute-offset a, 0\n")
10974 (write _test-input-stream "}\n")
10975
10976 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
10977
10978
10979 89/<- %edx 4/r32/esp
10980 (flush _test-output-buffered-file)
10981 (flush _test-error-buffered-file)
10982 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
10988
10989 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-wrong-output-type: output should be empty")
10990 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: output 'o' does not have the right type" "F - test-compute-offset-with-wrong-output-type: error message")
10991
10992 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-wrong-output-type: exit status")
10993
10994 81 0/subop/add %esp 8/imm32
10995
10996 5d/pop-to-ebp
10997 c3/return
10998
10999 test-compute-offset-with-wrong-output-compound-type:
11000
11001 55/push-ebp
11002 89/<- %ebp 4/r32/esp
11003
11004 (clear-stream _test-input-stream)
11005 (clear-stream $_test-input-buffered-file->buffer)
11006 (clear-stream _test-output-stream)
11007 (clear-stream $_test-output-buffered-file->buffer)
11008 (clear-stream _test-error-stream)
11009 (clear-stream $_test-error-buffered-file->buffer)
11010
11011 68/push 0/imm32
11012 68/push 0/imm32
11013 89/<- %edx 4/r32/esp
11014 (tailor-exit-descriptor %edx 0x10)
11015
11016 (write _test-input-stream "fn foo {\n")
11017 (write _test-input-stream " var a/ebx: (addr array handle boolean) <- copy 0\n")
11018 (write _test-input-stream " var o/edi: (offset handle int) <- compute-offset a, 0\n")
11019 (write _test-input-stream "}\n")
11020
11021 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11022
11023
11024 89/<- %edx 4/r32/esp
11025 (flush _test-output-buffered-file)
11026 (flush _test-error-buffered-file)
11027 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11033
11034 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-wrong-output-compound-type: output should be empty")
11035 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: output 'o' does not have the right type" "F - test-compute-offset-with-wrong-output-compound-type: error message")
11036
11037 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-wrong-output-compound-type: exit status")
11038
11039 81 0/subop/add %esp 8/imm32
11040
11041 5d/pop-to-ebp
11042 c3/return
11043
11044 test-compute-offset-with-no-inouts:
11045
11046 55/push-ebp
11047 89/<- %ebp 4/r32/esp
11048
11049 (clear-stream _test-input-stream)
11050 (clear-stream $_test-input-buffered-file->buffer)
11051 (clear-stream _test-output-stream)
11052 (clear-stream $_test-output-buffered-file->buffer)
11053 (clear-stream _test-error-stream)
11054 (clear-stream $_test-error-buffered-file->buffer)
11055
11056 68/push 0/imm32
11057 68/push 0/imm32
11058 89/<- %edx 4/r32/esp
11059 (tailor-exit-descriptor %edx 0x10)
11060
11061 (write _test-input-stream "fn foo {\n")
11062 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset\n")
11063 (write _test-input-stream "}\n")
11064
11065 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11066
11067
11068 89/<- %edx 4/r32/esp
11069 (flush _test-output-buffered-file)
11070 (flush _test-error-buffered-file)
11071 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11077
11078 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-no-inouts: output should be empty")
11079 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: too few inouts (2 required)" "F - test-compute-offset-with-no-inouts: error message")
11080
11081 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-no-inouts: exit status")
11082
11083 81 0/subop/add %esp 8/imm32
11084
11085 5d/pop-to-ebp
11086 c3/return
11087
11088 test-compute-offset-with-too-few-inouts:
11089
11090 55/push-ebp
11091 89/<- %ebp 4/r32/esp
11092
11093 (clear-stream _test-input-stream)
11094 (clear-stream $_test-input-buffered-file->buffer)
11095 (clear-stream _test-output-stream)
11096 (clear-stream $_test-output-buffered-file->buffer)
11097 (clear-stream _test-error-stream)
11098 (clear-stream $_test-error-buffered-file->buffer)
11099
11100 68/push 0/imm32
11101 68/push 0/imm32
11102 89/<- %edx 4/r32/esp
11103 (tailor-exit-descriptor %edx 0x10)
11104
11105 (write _test-input-stream "fn foo {\n")
11106 (write _test-input-stream " var a: (array int 3)\n")
11107 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a\n")
11108 (write _test-input-stream "}\n")
11109
11110 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11111
11112
11113 89/<- %edx 4/r32/esp
11114 (flush _test-output-buffered-file)
11115 (flush _test-error-buffered-file)
11116 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11122
11123 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-too-few-inouts: output should be empty")
11124 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: too few inouts (2 required)" "F - test-compute-offset-with-too-few-inouts: error message")
11125
11126 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-too-few-inouts: exit status")
11127
11128 81 0/subop/add %esp 8/imm32
11129
11130 5d/pop-to-ebp
11131 c3/return
11132
11133 test-compute-offset-with-too-many-inouts:
11134
11135 55/push-ebp
11136 89/<- %ebp 4/r32/esp
11137
11138 (clear-stream _test-input-stream)
11139 (clear-stream $_test-input-buffered-file->buffer)
11140 (clear-stream _test-output-stream)
11141 (clear-stream $_test-output-buffered-file->buffer)
11142 (clear-stream _test-error-stream)
11143 (clear-stream $_test-error-buffered-file->buffer)
11144
11145 68/push 0/imm32
11146 68/push 0/imm32
11147 89/<- %edx 4/r32/esp
11148 (tailor-exit-descriptor %edx 0x10)
11149
11150 (write _test-input-stream "fn foo {\n")
11151 (write _test-input-stream " var a: (array int 3)\n")
11152 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0, 0\n")
11153 (write _test-input-stream "}\n")
11154
11155 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11156
11157
11158 89/<- %edx 4/r32/esp
11159 (flush _test-output-buffered-file)
11160 (flush _test-error-buffered-file)
11161 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11167
11168 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-too-many-inouts: output should be empty")
11169 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: too many inouts (2 required)" "F - test-compute-offset-with-too-many-inouts: error message")
11170
11171 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-too-many-inouts: exit status")
11172
11173 81 0/subop/add %esp 8/imm32
11174
11175 5d/pop-to-ebp
11176 c3/return
11177
11178 test-compute-offset-with-no-output:
11179
11180 55/push-ebp
11181 89/<- %ebp 4/r32/esp
11182
11183 (clear-stream _test-input-stream)
11184 (clear-stream $_test-input-buffered-file->buffer)
11185 (clear-stream _test-output-stream)
11186 (clear-stream $_test-output-buffered-file->buffer)
11187 (clear-stream _test-error-stream)
11188 (clear-stream $_test-error-buffered-file->buffer)
11189
11190 68/push 0/imm32
11191 68/push 0/imm32
11192 89/<- %edx 4/r32/esp
11193 (tailor-exit-descriptor %edx 0x10)
11194
11195 (write _test-input-stream "fn foo {\n")
11196 (write _test-input-stream " var a: (array int 3)\n")
11197 (write _test-input-stream " compute-offset a, 0\n")
11198 (write _test-input-stream "}\n")
11199
11200 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11201
11202
11203 89/<- %edx 4/r32/esp
11204 (flush _test-output-buffered-file)
11205 (flush _test-error-buffered-file)
11206 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11212
11213 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-no-output: output should be empty")
11214 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: must have an output" "F - test-compute-offset-with-no-output: error message")
11215
11216 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-no-output: exit status")
11217
11218 81 0/subop/add %esp 8/imm32
11219
11220 5d/pop-to-ebp
11221 c3/return
11222
11223 test-compute-offset-with-too-many-outputs:
11224
11225 55/push-ebp
11226 89/<- %ebp 4/r32/esp
11227
11228 (clear-stream _test-input-stream)
11229 (clear-stream $_test-input-buffered-file->buffer)
11230 (clear-stream _test-output-stream)
11231 (clear-stream $_test-output-buffered-file->buffer)
11232 (clear-stream _test-error-stream)
11233 (clear-stream $_test-error-buffered-file->buffer)
11234
11235 68/push 0/imm32
11236 68/push 0/imm32
11237 89/<- %edx 4/r32/esp
11238 (tailor-exit-descriptor %edx 0x10)
11239
11240 (write _test-input-stream "fn foo {\n")
11241 (write _test-input-stream " var a: (array int 3)\n")
11242 (write _test-input-stream " var b/eax: (offset int) <- compute-offset a, 0\n")
11243 (write _test-input-stream " var c/ecx: (addr int) <- copy 0\n")
11244 (write _test-input-stream " b, c <- compute-offset a, 0\n")
11245 (write _test-input-stream "}\n")
11246
11247 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11248
11249
11250 89/<- %edx 4/r32/esp
11251 (flush _test-output-buffered-file)
11252 (flush _test-error-buffered-file)
11253 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11259
11260 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-too-many-outputs: output should be empty")
11261 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: too many outputs (1 required)" "F - test-compute-offset-with-too-many-outputs: error message")
11262
11263 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-too-many-outputs: exit status")
11264
11265 81 0/subop/add %esp 8/imm32
11266
11267 5d/pop-to-ebp
11268 c3/return
11269
11270 test-convert-read-from-stream:
11271
11272 55/push-ebp
11273 89/<- %ebp 4/r32/esp
11274
11275 (clear-stream _test-input-stream)
11276 (clear-stream $_test-input-buffered-file->buffer)
11277 (clear-stream _test-output-stream)
11278 (clear-stream $_test-output-buffered-file->buffer)
11279
11280 (write _test-input-stream "fn foo {\n")
11281 (write _test-input-stream " var s/esi: (addr stream int) <- copy 0\n")
11282 (write _test-input-stream " var o/ecx: (addr int) <- copy 0\n")
11283 (write _test-input-stream " read-from-stream s, o\n")
11284 (write _test-input-stream "}\n")
11285
11286 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
11287
11288
11289 89/<- %edx 4/r32/esp
11290 (flush _test-output-buffered-file)
11291 (flush _test-error-buffered-file)
11292 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
11298
11299 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-read-from-stream/0")
11300 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-read-from-stream/1")
11301 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-read-from-stream/2")
11302 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-read-from-stream/3")
11303 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-read-from-stream/4")
11304 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-read-from-stream/5")
11305 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-read-from-stream/6")
11306 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-read-from-stream/7")
11307 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-read-from-stream/8")
11308 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-read-from-stream/9")
11309 (check-next-stream-line-equal _test-output-stream " (read-from-stream %esi %ecx 0x00000004)" "F - test-convert-read-from-stream/10")
11310 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-read-from-stream/11")
11311 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-read-from-stream/12")
11312 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-read-from-stream/13")
11313 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-read-from-stream/14")
11314 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-read-from-stream/15")
11315 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-read-from-stream/16")
11316 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-read-from-stream/17")
11317 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-read-from-stream/18")
11318
11319 89/<- %esp 5/r32/ebp
11320 5d/pop-to-ebp
11321 c3/return
11322
11323 test-convert-read-from-stream-with-correct-payload-size:
11324
11325 55/push-ebp
11326 89/<- %ebp 4/r32/esp
11327
11328 (clear-stream _test-input-stream)
11329 (clear-stream $_test-input-buffered-file->buffer)
11330 (clear-stream _test-output-stream)
11331 (clear-stream $_test-output-buffered-file->buffer)
11332
11333 (write _test-input-stream "fn foo {\n")
11334 (write _test-input-stream " var s/esi: (addr stream handle int) <- copy 0\n")
11335 (write _test-input-stream " var o/ecx: (addr handle int) <- copy 0\n")
11336 (write _test-input-stream " read-from-stream s, o\n")
11337 (write _test-input-stream "}\n")
11338
11339 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
11340
11341
11342 89/<- %edx 4/r32/esp
11343 (flush _test-output-buffered-file)
11344 (flush _test-error-buffered-file)
11345 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
11351
11352 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-read-from-stream-with-correct-payload-size/0")
11353 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-read-from-stream-with-correct-payload-size/1")
11354 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-read-from-stream-with-correct-payload-size/2")
11355 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-read-from-stream-with-correct-payload-size/3")
11356 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-read-from-stream-with-correct-payload-size/4")
11357 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-read-from-stream-with-correct-payload-size/5")
11358 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-read-from-stream-with-correct-payload-size/6")
11359 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-read-from-stream-with-correct-payload-size/7")
11360 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-read-from-stream-with-correct-payload-size/8")
11361 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-read-from-stream-with-correct-payload-size/9")
11362 (check-next-stream-line-equal _test-output-stream " (read-from-stream %esi %ecx 0x00000008)" "F - test-convert-read-from-stream-with-correct-payload-size/10")
11363 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-read-from-stream-with-correct-payload-size/11")
11364 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-read-from-stream-with-correct-payload-size/12")
11365 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-read-from-stream-with-correct-payload-size/13")
11366 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-read-from-stream-with-correct-payload-size/14")
11367 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-read-from-stream-with-correct-payload-size/15")
11368 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-read-from-stream-with-correct-payload-size/16")
11369 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-read-from-stream-with-correct-payload-size/17")
11370 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-read-from-stream-with-correct-payload-size/18")
11371
11372 89/<- %esp 5/r32/ebp
11373 5d/pop-to-ebp
11374 c3/return
11375
11376 test-read-from-stream-with-non-stream-atom-base-type:
11377
11378 55/push-ebp
11379 89/<- %ebp 4/r32/esp
11380
11381 (clear-stream _test-input-stream)
11382 (clear-stream $_test-input-buffered-file->buffer)
11383 (clear-stream _test-output-stream)
11384 (clear-stream $_test-output-buffered-file->buffer)
11385 (clear-stream _test-error-stream)
11386 (clear-stream $_test-error-buffered-file->buffer)
11387
11388 68/push 0/imm32
11389 68/push 0/imm32
11390 89/<- %edx 4/r32/esp
11391 (tailor-exit-descriptor %edx 0x10)
11392
11393 (write _test-input-stream "fn foo {\n")
11394 (write _test-input-stream " var a: int\n")
11395 (write _test-input-stream " read-from-stream a, 0\n")
11396 (write _test-input-stream "}\n")
11397
11398 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11399
11400
11401 89/<- %edx 4/r32/esp
11402 (flush _test-output-buffered-file)
11403 (flush _test-error-buffered-file)
11404 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11410
11411 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-non-stream-atom-base-type: output should be empty")
11412 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: var 'a' must be an addr to a stream" "F - test-read-from-stream-with-non-stream-atom-base-type: error message")
11413
11414 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-non-stream-atom-base-type: exit status")
11415
11416 81 0/subop/add %esp 8/imm32
11417
11418 5d/pop-to-ebp
11419 c3/return
11420
11421 test-read-from-stream-with-non-stream-compound-base-type:
11422
11423 55/push-ebp
11424 89/<- %ebp 4/r32/esp
11425
11426 (clear-stream _test-input-stream)
11427 (clear-stream $_test-input-buffered-file->buffer)
11428 (clear-stream _test-output-stream)
11429 (clear-stream $_test-output-buffered-file->buffer)
11430 (clear-stream _test-error-stream)
11431 (clear-stream $_test-error-buffered-file->buffer)
11432
11433 68/push 0/imm32
11434 68/push 0/imm32
11435 89/<- %edx 4/r32/esp
11436 (tailor-exit-descriptor %edx 0x10)
11437
11438 (write _test-input-stream "fn foo {\n")
11439 (write _test-input-stream " var a: (handle int)\n")
11440 (write _test-input-stream " read-from-stream a, 0\n")
11441 (write _test-input-stream "}\n")
11442
11443 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11444
11445
11446 89/<- %edx 4/r32/esp
11447 (flush _test-output-buffered-file)
11448 (flush _test-error-buffered-file)
11449 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11455
11456 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-non-stream-compound-base-type: output should be empty")
11457 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: var 'a' must be an addr to a stream" "F - test-read-from-stream-with-non-stream-compound-base-type: error message")
11458
11459 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-non-stream-compound-base-type: exit status")
11460
11461 81 0/subop/add %esp 8/imm32
11462
11463 5d/pop-to-ebp
11464 c3/return
11465
11466 test-read-from-stream-with-non-stream-compound-base-type-2:
11467
11468 55/push-ebp
11469 89/<- %ebp 4/r32/esp
11470
11471 (clear-stream _test-input-stream)
11472 (clear-stream $_test-input-buffered-file->buffer)
11473 (clear-stream _test-output-stream)
11474 (clear-stream $_test-output-buffered-file->buffer)
11475 (clear-stream _test-error-stream)
11476 (clear-stream $_test-error-buffered-file->buffer)
11477
11478 68/push 0/imm32
11479 68/push 0/imm32
11480 89/<- %edx 4/r32/esp
11481 (tailor-exit-descriptor %edx 0x10)
11482
11483 (write _test-input-stream "fn foo {\n")
11484 (write _test-input-stream " var a: (addr int)\n")
11485 (write _test-input-stream " read-from-stream a, 0\n")
11486 (write _test-input-stream "}\n")
11487
11488 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11489
11490
11491 89/<- %edx 4/r32/esp
11492 (flush _test-output-buffered-file)
11493 (flush _test-error-buffered-file)
11494 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11500
11501 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-non-stream-compound-base-type-2: output should be empty")
11502 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: var 'a' must be an addr to a stream" "F - test-read-from-stream-with-non-stream-compound-base-type-2: error message")
11503
11504 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-non-stream-compound-base-type-2: exit status")
11505
11506 81 0/subop/add %esp 8/imm32
11507
11508 5d/pop-to-ebp
11509 c3/return
11510
11511 test-read-from-stream-with-stream-atom-base-type:
11512
11513 55/push-ebp
11514 89/<- %ebp 4/r32/esp
11515
11516 (clear-stream _test-input-stream)
11517 (clear-stream $_test-input-buffered-file->buffer)
11518 (clear-stream _test-output-stream)
11519 (clear-stream $_test-output-buffered-file->buffer)
11520 (clear-stream _test-error-stream)
11521 (clear-stream $_test-error-buffered-file->buffer)
11522
11523 68/push 0/imm32
11524 68/push 0/imm32
11525 89/<- %edx 4/r32/esp
11526 (tailor-exit-descriptor %edx 0x10)
11527
11528 (write _test-input-stream "fn foo {\n")
11529 (write _test-input-stream " var a: stream\n")
11530 (write _test-input-stream " read-from-stream a, 0\n")
11531 (write _test-input-stream "}\n")
11532
11533 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11534
11535
11536 89/<- %edx 4/r32/esp
11537 (flush _test-output-buffered-file)
11538 (flush _test-error-buffered-file)
11539 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11545
11546 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-stream-atom-base-type: output should be empty")
11547 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: var 'a' must be an addr to a stream" "F - test-read-from-stream-with-stream-atom-base-type: error message")
11548
11549 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-stream-atom-base-type: exit status")
11550
11551 81 0/subop/add %esp 8/imm32
11552
11553 5d/pop-to-ebp
11554 c3/return
11555
11556 test-read-from-stream-with-wrong-index-type:
11557
11558 55/push-ebp
11559 89/<- %ebp 4/r32/esp
11560
11561 (clear-stream _test-input-stream)
11562 (clear-stream $_test-input-buffered-file->buffer)
11563 (clear-stream _test-output-stream)
11564 (clear-stream $_test-output-buffered-file->buffer)
11565 (clear-stream _test-error-stream)
11566 (clear-stream $_test-error-buffered-file->buffer)
11567
11568 68/push 0/imm32
11569 68/push 0/imm32
11570 89/<- %edx 4/r32/esp
11571 (tailor-exit-descriptor %edx 0x10)
11572
11573 (write _test-input-stream "fn foo {\n")
11574 (write _test-input-stream " var a/eax: (addr stream int) <- copy 0\n")
11575 (write _test-input-stream " var b: boolean\n")
11576 (write _test-input-stream " read-from-stream a, b\n")
11577 (write _test-input-stream "}\n")
11578
11579 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11580
11581
11582 89/<- %edx 4/r32/esp
11583 (flush _test-output-buffered-file)
11584 (flush _test-error-buffered-file)
11585 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11591
11592 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-wrong-index-type: output should be empty")
11593 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: target 'b' must be an addr" "F - test-read-from-stream-with-wrong-index-type: error message")
11594
11595 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-wrong-index-type: exit status")
11596
11597 81 0/subop/add %esp 8/imm32
11598
11599 5d/pop-to-ebp
11600 c3/return
11601
11602 test-read-from-stream-with-no-inouts:
11603
11604 55/push-ebp
11605 89/<- %ebp 4/r32/esp
11606
11607 (clear-stream _test-input-stream)
11608 (clear-stream $_test-input-buffered-file->buffer)
11609 (clear-stream _test-output-stream)
11610 (clear-stream $_test-output-buffered-file->buffer)
11611 (clear-stream _test-error-stream)
11612 (clear-stream $_test-error-buffered-file->buffer)
11613
11614 68/push 0/imm32
11615 68/push 0/imm32
11616 89/<- %edx 4/r32/esp
11617 (tailor-exit-descriptor %edx 0x10)
11618
11619 (write _test-input-stream "fn foo {\n")
11620 (write _test-input-stream " read-from-stream\n")
11621 (write _test-input-stream "}\n")
11622
11623 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11624
11625
11626 89/<- %edx 4/r32/esp
11627 (flush _test-output-buffered-file)
11628 (flush _test-error-buffered-file)
11629 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11635
11636 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-no-inouts: output should be empty")
11637 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: too few inouts (2 required)" "F - test-read-from-stream-with-no-inouts: error message")
11638
11639 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-no-inouts: exit status")
11640
11641 81 0/subop/add %esp 8/imm32
11642
11643 5d/pop-to-ebp
11644 c3/return
11645
11646 test-read-from-stream-with-too-few-inouts:
11647
11648 55/push-ebp
11649 89/<- %ebp 4/r32/esp
11650
11651 (clear-stream _test-input-stream)
11652 (clear-stream $_test-input-buffered-file->buffer)
11653 (clear-stream _test-output-stream)
11654 (clear-stream $_test-output-buffered-file->buffer)
11655 (clear-stream _test-error-stream)
11656 (clear-stream $_test-error-buffered-file->buffer)
11657
11658 68/push 0/imm32
11659 68/push 0/imm32
11660 89/<- %edx 4/r32/esp
11661 (tailor-exit-descriptor %edx 0x10)
11662
11663 (write _test-input-stream "fn foo {\n")
11664 (write _test-input-stream " var a: (addr stream int)\n")
11665 (write _test-input-stream " read-from-stream a\n")
11666 (write _test-input-stream "}\n")
11667
11668 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11669
11670
11671 89/<- %edx 4/r32/esp
11672 (flush _test-output-buffered-file)
11673 (flush _test-error-buffered-file)
11674 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11680
11681 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-too-few-inouts: output should be empty")
11682 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: too few inouts (2 required)" "F - test-read-from-stream-with-too-few-inouts: error message")
11683
11684 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-too-few-inouts: exit status")
11685
11686 81 0/subop/add %esp 8/imm32
11687
11688 5d/pop-to-ebp
11689 c3/return
11690
11691 test-read-from-stream-with-too-many-inouts:
11692
11693 55/push-ebp
11694 89/<- %ebp 4/r32/esp
11695
11696 (clear-stream _test-input-stream)
11697 (clear-stream $_test-input-buffered-file->buffer)
11698 (clear-stream _test-output-stream)
11699 (clear-stream $_test-output-buffered-file->buffer)
11700 (clear-stream _test-error-stream)
11701 (clear-stream $_test-error-buffered-file->buffer)
11702
11703 68/push 0/imm32
11704 68/push 0/imm32
11705 89/<- %edx 4/r32/esp
11706 (tailor-exit-descriptor %edx 0x10)
11707
11708 (write _test-input-stream "fn foo {\n")
11709 (write _test-input-stream " var a: (addr stream int)\n")
11710 (write _test-input-stream " var b: (addr int)\n")
11711 (write _test-input-stream " read-from-stream a, b, 0\n")
11712 (write _test-input-stream "}\n")
11713
11714 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11715
11716
11717 89/<- %edx 4/r32/esp
11718 (flush _test-output-buffered-file)
11719 (flush _test-error-buffered-file)
11720 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11726
11727 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-too-many-inouts: output should be empty")
11728 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: too many inouts (2 required)" "F - test-read-from-stream-with-too-many-inouts: error message")
11729
11730 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-too-many-inouts: exit status")
11731
11732 81 0/subop/add %esp 8/imm32
11733
11734 5d/pop-to-ebp
11735 c3/return
11736
11737 test-read-from-stream-with-output:
11738
11739 55/push-ebp
11740 89/<- %ebp 4/r32/esp
11741
11742 (clear-stream _test-input-stream)
11743 (clear-stream $_test-input-buffered-file->buffer)
11744 (clear-stream _test-output-stream)
11745 (clear-stream $_test-output-buffered-file->buffer)
11746 (clear-stream _test-error-stream)
11747 (clear-stream $_test-error-buffered-file->buffer)
11748
11749 68/push 0/imm32
11750 68/push 0/imm32
11751 89/<- %edx 4/r32/esp
11752 (tailor-exit-descriptor %edx 0x10)
11753
11754 (write _test-input-stream "fn foo {\n")
11755 (write _test-input-stream " var a: (addr stream int)\n")
11756 (write _test-input-stream " var b/eax: (addr int) <- copy 0\n")
11757 (write _test-input-stream " b <- read-from-stream a, b\n")
11758 (write _test-input-stream "}\n")
11759
11760 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11761
11762
11763 89/<- %edx 4/r32/esp
11764 (flush _test-output-buffered-file)
11765 (flush _test-error-buffered-file)
11766 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11772
11773 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-output: output should be empty")
11774 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: unexpected output" "F - test-read-from-stream-with-output: error message")
11775
11776 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-output: exit status")
11777
11778 81 0/subop/add %esp 8/imm32
11779
11780 5d/pop-to-ebp
11781 c3/return
11782
11783 test-convert-write-to-stream:
11784
11785 55/push-ebp
11786 89/<- %ebp 4/r32/esp
11787
11788 (clear-stream _test-input-stream)
11789 (clear-stream $_test-input-buffered-file->buffer)
11790 (clear-stream _test-output-stream)
11791 (clear-stream $_test-output-buffered-file->buffer)
11792
11793 (write _test-input-stream "fn foo {\n")
11794 (write _test-input-stream " var s/esi: (addr stream int) <- copy 0\n")
11795 (write _test-input-stream " var o/ecx: (addr int) <- copy 0\n")
11796 (write _test-input-stream " write-to-stream s, o\n")
11797 (write _test-input-stream "}\n")
11798
11799 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
11800
11801
11802 89/<- %edx 4/r32/esp
11803 (flush _test-output-buffered-file)
11804 (flush _test-error-buffered-file)
11805 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
11811
11812 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-write-to-stream/0")
11813 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-write-to-stream/1")
11814 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-write-to-stream/2")
11815 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-write-to-stream/3")
11816 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-write-to-stream/4")
11817 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-write-to-stream/5")
11818 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-write-to-stream/6")
11819 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-write-to-stream/7")
11820 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-write-to-stream/8")
11821 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-write-to-stream/9")
11822 (check-next-stream-line-equal _test-output-stream " (write-to-stream %esi %ecx 0x00000004)" "F - test-convert-write-to-stream/10")
11823 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-write-to-stream/11")
11824 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-write-to-stream/12")
11825 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-write-to-stream/13")
11826 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-write-to-stream/14")
11827 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-write-to-stream/15")
11828 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-write-to-stream/16")
11829 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-write-to-stream/17")
11830 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-write-to-stream/18")
11831
11832 89/<- %esp 5/r32/ebp
11833 5d/pop-to-ebp
11834 c3/return
11835
11836 test-convert-write-to-stream-with-correct-payload-size:
11837
11838 55/push-ebp
11839 89/<- %ebp 4/r32/esp
11840
11841 (clear-stream _test-input-stream)
11842 (clear-stream $_test-input-buffered-file->buffer)
11843 (clear-stream _test-output-stream)
11844 (clear-stream $_test-output-buffered-file->buffer)
11845
11846 (write _test-input-stream "fn foo {\n")
11847 (write _test-input-stream " var s/esi: (addr stream handle int) <- copy 0\n")
11848 (write _test-input-stream " var o/ecx: (addr handle int) <- copy 0\n")
11849 (write _test-input-stream " write-to-stream s, o\n")
11850 (write _test-input-stream "}\n")
11851
11852 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
11853
11854
11855 89/<- %edx 4/r32/esp
11856 (flush _test-output-buffered-file)
11857 (flush _test-error-buffered-file)
11858 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
11864
11865 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-write-to-stream-with-correct-payload-size/0")
11866 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-write-to-stream-with-correct-payload-size/1")
11867 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-write-to-stream-with-correct-payload-size/2")
11868 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-write-to-stream-with-correct-payload-size/3")
11869 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-write-to-stream-with-correct-payload-size/4")
11870 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-write-to-stream-with-correct-payload-size/5")
11871 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-write-to-stream-with-correct-payload-size/6")
11872 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-write-to-stream-with-correct-payload-size/7")
11873 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-write-to-stream-with-correct-payload-size/8")
11874 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-write-to-stream-with-correct-payload-size/9")
11875 (check-next-stream-line-equal _test-output-stream " (write-to-stream %esi %ecx 0x00000008)" "F - test-convert-write-to-stream-with-correct-payload-size/10")
11876 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-write-to-stream-with-correct-payload-size/11")
11877 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-write-to-stream-with-correct-payload-size/12")
11878 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-write-to-stream-with-correct-payload-size/13")
11879 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-write-to-stream-with-correct-payload-size/14")
11880 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-write-to-stream-with-correct-payload-size/15")
11881 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-write-to-stream-with-correct-payload-size/16")
11882 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-write-to-stream-with-correct-payload-size/17")
11883 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-write-to-stream-with-correct-payload-size/18")
11884
11885 89/<- %esp 5/r32/ebp
11886 5d/pop-to-ebp
11887 c3/return
11888
11889 test-write-to-stream-with-non-stream-atom-base-type:
11890
11891 55/push-ebp
11892 89/<- %ebp 4/r32/esp
11893
11894 (clear-stream _test-input-stream)
11895 (clear-stream $_test-input-buffered-file->buffer)
11896 (clear-stream _test-output-stream)
11897 (clear-stream $_test-output-buffered-file->buffer)
11898 (clear-stream _test-error-stream)
11899 (clear-stream $_test-error-buffered-file->buffer)
11900
11901 68/push 0/imm32
11902 68/push 0/imm32
11903 89/<- %edx 4/r32/esp
11904 (tailor-exit-descriptor %edx 0x10)
11905
11906 (write _test-input-stream "fn foo {\n")
11907 (write _test-input-stream " var a: int\n")
11908 (write _test-input-stream " write-to-stream a, 0\n")
11909 (write _test-input-stream "}\n")
11910
11911 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11912
11913
11914 89/<- %edx 4/r32/esp
11915 (flush _test-output-buffered-file)
11916 (flush _test-error-buffered-file)
11917 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11923
11924 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-non-stream-atom-base-type: output should be empty")
11925 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: var 'a' must be an addr to a stream" "F - test-write-to-stream-with-non-stream-atom-base-type: error message")
11926
11927 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-non-stream-atom-base-type: exit status")
11928
11929 81 0/subop/add %esp 8/imm32
11930
11931 5d/pop-to-ebp
11932 c3/return
11933
11934 test-write-to-stream-with-non-stream-compound-base-type:
11935
11936 55/push-ebp
11937 89/<- %ebp 4/r32/esp
11938
11939 (clear-stream _test-input-stream)
11940 (clear-stream $_test-input-buffered-file->buffer)
11941 (clear-stream _test-output-stream)
11942 (clear-stream $_test-output-buffered-file->buffer)
11943 (clear-stream _test-error-stream)
11944 (clear-stream $_test-error-buffered-file->buffer)
11945
11946 68/push 0/imm32
11947 68/push 0/imm32
11948 89/<- %edx 4/r32/esp
11949 (tailor-exit-descriptor %edx 0x10)
11950
11951 (write _test-input-stream "fn foo {\n")
11952 (write _test-input-stream " var a: (handle int)\n")
11953 (write _test-input-stream " write-to-stream a, 0\n")
11954 (write _test-input-stream "}\n")
11955
11956 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
11957
11958
11959 89/<- %edx 4/r32/esp
11960 (flush _test-output-buffered-file)
11961 (flush _test-error-buffered-file)
11962 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
11968
11969 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-non-stream-compound-base-type: output should be empty")
11970 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: var 'a' must be an addr to a stream" "F - test-write-to-stream-with-non-stream-compound-base-type: error message")
11971
11972 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-non-stream-compound-base-type: exit status")
11973
11974 81 0/subop/add %esp 8/imm32
11975
11976 5d/pop-to-ebp
11977 c3/return
11978
11979 test-write-to-stream-with-non-stream-compound-base-type-2:
11980
11981 55/push-ebp
11982 89/<- %ebp 4/r32/esp
11983
11984 (clear-stream _test-input-stream)
11985 (clear-stream $_test-input-buffered-file->buffer)
11986 (clear-stream _test-output-stream)
11987 (clear-stream $_test-output-buffered-file->buffer)
11988 (clear-stream _test-error-stream)
11989 (clear-stream $_test-error-buffered-file->buffer)
11990
11991 68/push 0/imm32
11992 68/push 0/imm32
11993 89/<- %edx 4/r32/esp
11994 (tailor-exit-descriptor %edx 0x10)
11995
11996 (write _test-input-stream "fn foo {\n")
11997 (write _test-input-stream " var a: (addr int)\n")
11998 (write _test-input-stream " write-to-stream a, 0\n")
11999 (write _test-input-stream "}\n")
12000
12001 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12002
12003
12004 89/<- %edx 4/r32/esp
12005 (flush _test-output-buffered-file)
12006 (flush _test-error-buffered-file)
12007 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12013
12014 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-non-stream-compound-base-type-2: output should be empty")
12015 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: var 'a' must be an addr to a stream" "F - test-write-to-stream-with-non-stream-compound-base-type-2: error message")
12016
12017 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-non-stream-compound-base-type-2: exit status")
12018
12019 81 0/subop/add %esp 8/imm32
12020
12021 5d/pop-to-ebp
12022 c3/return
12023
12024 test-write-to-stream-with-stream-atom-base-type:
12025
12026 55/push-ebp
12027 89/<- %ebp 4/r32/esp
12028
12029 (clear-stream _test-input-stream)
12030 (clear-stream $_test-input-buffered-file->buffer)
12031 (clear-stream _test-output-stream)
12032 (clear-stream $_test-output-buffered-file->buffer)
12033 (clear-stream _test-error-stream)
12034 (clear-stream $_test-error-buffered-file->buffer)
12035
12036 68/push 0/imm32
12037 68/push 0/imm32
12038 89/<- %edx 4/r32/esp
12039 (tailor-exit-descriptor %edx 0x10)
12040
12041 (write _test-input-stream "fn foo {\n")
12042 (write _test-input-stream " var a: stream\n")
12043 (write _test-input-stream " write-to-stream a, 0\n")
12044 (write _test-input-stream "}\n")
12045
12046 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12047
12048
12049 89/<- %edx 4/r32/esp
12050 (flush _test-output-buffered-file)
12051 (flush _test-error-buffered-file)
12052 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12058
12059 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-stream-atom-base-type: output should be empty")
12060 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: var 'a' must be an addr to a stream" "F - test-write-to-stream-with-stream-atom-base-type: error message")
12061
12062 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-stream-atom-base-type: exit status")
12063
12064 81 0/subop/add %esp 8/imm32
12065
12066 5d/pop-to-ebp
12067 c3/return
12068
12069 test-write-to-stream-with-wrong-index-type:
12070
12071 55/push-ebp
12072 89/<- %ebp 4/r32/esp
12073
12074 (clear-stream _test-input-stream)
12075 (clear-stream $_test-input-buffered-file->buffer)
12076 (clear-stream _test-output-stream)
12077 (clear-stream $_test-output-buffered-file->buffer)
12078 (clear-stream _test-error-stream)
12079 (clear-stream $_test-error-buffered-file->buffer)
12080
12081 68/push 0/imm32
12082 68/push 0/imm32
12083 89/<- %edx 4/r32/esp
12084 (tailor-exit-descriptor %edx 0x10)
12085
12086 (write _test-input-stream "fn foo {\n")
12087 (write _test-input-stream " var a/eax: (addr stream int) <- copy 0\n")
12088 (write _test-input-stream " var b: boolean\n")
12089 (write _test-input-stream " write-to-stream a, b\n")
12090 (write _test-input-stream "}\n")
12091
12092 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12093
12094
12095 89/<- %edx 4/r32/esp
12096 (flush _test-output-buffered-file)
12097 (flush _test-error-buffered-file)
12098 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12104
12105 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-wrong-index-type: output should be empty")
12106 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: target 'b' must be an addr" "F - test-write-to-stream-with-wrong-index-type: error message")
12107
12108 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-wrong-index-type: exit status")
12109
12110 81 0/subop/add %esp 8/imm32
12111
12112 5d/pop-to-ebp
12113 c3/return
12114
12115 test-write-to-stream-with-no-inouts:
12116
12117 55/push-ebp
12118 89/<- %ebp 4/r32/esp
12119
12120 (clear-stream _test-input-stream)
12121 (clear-stream $_test-input-buffered-file->buffer)
12122 (clear-stream _test-output-stream)
12123 (clear-stream $_test-output-buffered-file->buffer)
12124 (clear-stream _test-error-stream)
12125 (clear-stream $_test-error-buffered-file->buffer)
12126
12127 68/push 0/imm32
12128 68/push 0/imm32
12129 89/<- %edx 4/r32/esp
12130 (tailor-exit-descriptor %edx 0x10)
12131
12132 (write _test-input-stream "fn foo {\n")
12133 (write _test-input-stream " write-to-stream\n")
12134 (write _test-input-stream "}\n")
12135
12136 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12137
12138
12139 89/<- %edx 4/r32/esp
12140 (flush _test-output-buffered-file)
12141 (flush _test-error-buffered-file)
12142 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12148
12149 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-no-inouts: output should be empty")
12150 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: too few inouts (2 required)" "F - test-write-to-stream-with-no-inouts: error message")
12151
12152 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-no-inouts: exit status")
12153
12154 81 0/subop/add %esp 8/imm32
12155
12156 5d/pop-to-ebp
12157 c3/return
12158
12159 test-write-to-stream-with-too-few-inouts:
12160
12161 55/push-ebp
12162 89/<- %ebp 4/r32/esp
12163
12164 (clear-stream _test-input-stream)
12165 (clear-stream $_test-input-buffered-file->buffer)
12166 (clear-stream _test-output-stream)
12167 (clear-stream $_test-output-buffered-file->buffer)
12168 (clear-stream _test-error-stream)
12169 (clear-stream $_test-error-buffered-file->buffer)
12170
12171 68/push 0/imm32
12172 68/push 0/imm32
12173 89/<- %edx 4/r32/esp
12174 (tailor-exit-descriptor %edx 0x10)
12175
12176 (write _test-input-stream "fn foo {\n")
12177 (write _test-input-stream " var a: (addr stream int)\n")
12178 (write _test-input-stream " write-to-stream a\n")
12179 (write _test-input-stream "}\n")
12180
12181 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12182
12183
12184 89/<- %edx 4/r32/esp
12185 (flush _test-output-buffered-file)
12186 (flush _test-error-buffered-file)
12187 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12193
12194 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-too-few-inouts: output should be empty")
12195 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: too few inouts (2 required)" "F - test-write-to-stream-with-too-few-inouts: error message")
12196
12197 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-too-few-inouts: exit status")
12198
12199 81 0/subop/add %esp 8/imm32
12200
12201 5d/pop-to-ebp
12202 c3/return
12203
12204 test-write-to-stream-with-too-many-inouts:
12205
12206 55/push-ebp
12207 89/<- %ebp 4/r32/esp
12208
12209 (clear-stream _test-input-stream)
12210 (clear-stream $_test-input-buffered-file->buffer)
12211 (clear-stream _test-output-stream)
12212 (clear-stream $_test-output-buffered-file->buffer)
12213 (clear-stream _test-error-stream)
12214 (clear-stream $_test-error-buffered-file->buffer)
12215
12216 68/push 0/imm32
12217 68/push 0/imm32
12218 89/<- %edx 4/r32/esp
12219 (tailor-exit-descriptor %edx 0x10)
12220
12221 (write _test-input-stream "fn foo {\n")
12222 (write _test-input-stream " var a: (addr stream int)\n")
12223 (write _test-input-stream " var b: (addr int)\n")
12224 (write _test-input-stream " write-to-stream a, b, 0\n")
12225 (write _test-input-stream "}\n")
12226
12227 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12228
12229
12230 89/<- %edx 4/r32/esp
12231 (flush _test-output-buffered-file)
12232 (flush _test-error-buffered-file)
12233 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12239
12240 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-too-many-inouts: output should be empty")
12241 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: too many inouts (2 required)" "F - test-write-to-stream-with-too-many-inouts: error message")
12242
12243 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-too-many-inouts: exit status")
12244
12245 81 0/subop/add %esp 8/imm32
12246
12247 5d/pop-to-ebp
12248 c3/return
12249
12250 test-write-to-stream-with-output:
12251
12252 55/push-ebp
12253 89/<- %ebp 4/r32/esp
12254
12255 (clear-stream _test-input-stream)
12256 (clear-stream $_test-input-buffered-file->buffer)
12257 (clear-stream _test-output-stream)
12258 (clear-stream $_test-output-buffered-file->buffer)
12259 (clear-stream _test-error-stream)
12260 (clear-stream $_test-error-buffered-file->buffer)
12261
12262 68/push 0/imm32
12263 68/push 0/imm32
12264 89/<- %edx 4/r32/esp
12265 (tailor-exit-descriptor %edx 0x10)
12266
12267 (write _test-input-stream "fn foo {\n")
12268 (write _test-input-stream " var a: (addr stream int)\n")
12269 (write _test-input-stream " var b/eax: (addr int) <- copy 0\n")
12270 (write _test-input-stream " b <- write-to-stream a, b\n")
12271 (write _test-input-stream "}\n")
12272
12273 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12274
12275
12276 89/<- %edx 4/r32/esp
12277 (flush _test-output-buffered-file)
12278 (flush _test-error-buffered-file)
12279 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12285
12286 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-output: output should be empty")
12287 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: unexpected output" "F - test-write-to-stream-with-output: error message")
12288
12289 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-output: exit status")
12290
12291 81 0/subop/add %esp 8/imm32
12292
12293 5d/pop-to-ebp
12294 c3/return
12295
12296 test-length-with-non-array-atom-base-type:
12297
12298 55/push-ebp
12299 89/<- %ebp 4/r32/esp
12300
12301 (clear-stream _test-input-stream)
12302 (clear-stream $_test-input-buffered-file->buffer)
12303 (clear-stream _test-output-stream)
12304 (clear-stream $_test-output-buffered-file->buffer)
12305 (clear-stream _test-error-stream)
12306 (clear-stream $_test-error-buffered-file->buffer)
12307
12308 68/push 0/imm32
12309 68/push 0/imm32
12310 89/<- %edx 4/r32/esp
12311 (tailor-exit-descriptor %edx 0x10)
12312
12313 (write _test-input-stream "fn foo {\n")
12314 (write _test-input-stream " var a: int\n")
12315 (write _test-input-stream " var c/ecx: int <- length a\n")
12316 (write _test-input-stream "}\n")
12317
12318 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12319
12320
12321 89/<- %edx 4/r32/esp
12322 (flush _test-output-buffered-file)
12323 (flush _test-error-buffered-file)
12324 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12330
12331 (check-stream-equal _test-output-stream "" "F - test-length-with-non-array-atom-base-type: output should be empty")
12332 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: var 'a' is not an array" "F - test-length-with-non-array-atom-base-type: error message")
12333
12334 (check-ints-equal *(edx+4) 2 "F - test-length-with-non-array-atom-base-type: exit status")
12335
12336 81 0/subop/add %esp 8/imm32
12337
12338 5d/pop-to-ebp
12339 c3/return
12340
12341 test-length-with-non-array-compound-base-type:
12342
12343 55/push-ebp
12344 89/<- %ebp 4/r32/esp
12345
12346 (clear-stream _test-input-stream)
12347 (clear-stream $_test-input-buffered-file->buffer)
12348 (clear-stream _test-output-stream)
12349 (clear-stream $_test-output-buffered-file->buffer)
12350 (clear-stream _test-error-stream)
12351 (clear-stream $_test-error-buffered-file->buffer)
12352
12353 68/push 0/imm32
12354 68/push 0/imm32
12355 89/<- %edx 4/r32/esp
12356 (tailor-exit-descriptor %edx 0x10)
12357
12358 (write _test-input-stream "fn foo {\n")
12359 (write _test-input-stream " var a: (handle int)\n")
12360 (write _test-input-stream " var c/ecx: (addr int) <- length a, 0\n")
12361 (write _test-input-stream "}\n")
12362
12363 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12364
12365
12366 89/<- %edx 4/r32/esp
12367 (flush _test-output-buffered-file)
12368 (flush _test-error-buffered-file)
12369 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12375
12376 (check-stream-equal _test-output-stream "" "F - test-length-with-non-array-compound-base-type: output should be empty")
12377 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: var 'a' is not an array" "F - test-length-with-non-array-compound-base-type: error message")
12378
12379 (check-ints-equal *(edx+4) 2 "F - test-length-with-non-array-compound-base-type: exit status")
12380
12381 81 0/subop/add %esp 8/imm32
12382
12383 5d/pop-to-ebp
12384 c3/return
12385
12386 test-length-with-non-array-compound-base-type-2:
12387
12388 55/push-ebp
12389 89/<- %ebp 4/r32/esp
12390
12391 (clear-stream _test-input-stream)
12392 (clear-stream $_test-input-buffered-file->buffer)
12393 (clear-stream _test-output-stream)
12394 (clear-stream $_test-output-buffered-file->buffer)
12395 (clear-stream _test-error-stream)
12396 (clear-stream $_test-error-buffered-file->buffer)
12397
12398 68/push 0/imm32
12399 68/push 0/imm32
12400 89/<- %edx 4/r32/esp
12401 (tailor-exit-descriptor %edx 0x10)
12402
12403 (write _test-input-stream "fn foo {\n")
12404 (write _test-input-stream " var a: (addr int)\n")
12405 (write _test-input-stream " var c/ecx: (addr int) <- length a, 0\n")
12406 (write _test-input-stream "}\n")
12407
12408 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12409
12410
12411 89/<- %edx 4/r32/esp
12412 (flush _test-output-buffered-file)
12413 (flush _test-error-buffered-file)
12414 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12420
12421 (check-stream-equal _test-output-stream "" "F - test-length-with-non-array-compound-base-type-2: output should be empty")
12422 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: var 'a' is not an array" "F - test-length-with-non-array-compound-base-type-2: error message")
12423
12424 (check-ints-equal *(edx+4) 2 "F - test-length-with-non-array-compound-base-type-2: exit status")
12425
12426 81 0/subop/add %esp 8/imm32
12427
12428 5d/pop-to-ebp
12429 c3/return
12430
12431 test-length-with-array-atom-base-type:
12432
12433 55/push-ebp
12434 89/<- %ebp 4/r32/esp
12435
12436 (clear-stream _test-input-stream)
12437 (clear-stream $_test-input-buffered-file->buffer)
12438 (clear-stream _test-output-stream)
12439 (clear-stream $_test-output-buffered-file->buffer)
12440 (clear-stream _test-error-stream)
12441 (clear-stream $_test-error-buffered-file->buffer)
12442
12443 68/push 0/imm32
12444 68/push 0/imm32
12445 89/<- %edx 4/r32/esp
12446 (tailor-exit-descriptor %edx 0x10)
12447
12448 (write _test-input-stream "fn foo {\n")
12449 (write _test-input-stream " var a: array\n")
12450 (write _test-input-stream " var c/ecx: (addr int) <- length a\n")
12451 (write _test-input-stream "}\n")
12452
12453 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12454
12455
12456 89/<- %edx 4/r32/esp
12457 (flush _test-output-buffered-file)
12458 (flush _test-error-buffered-file)
12459 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12465
12466 (check-stream-equal _test-output-stream "" "F - test-length-with-array-atom-base-type: output should be empty")
12467 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: array 'a' must specify the type of its elements" "F - test-length-with-array-atom-base-type: error message")
12468
12469 (check-ints-equal *(edx+4) 2 "F - test-length-with-array-atom-base-type: exit status")
12470
12471 81 0/subop/add %esp 8/imm32
12472
12473 5d/pop-to-ebp
12474 c3/return
12475
12476 test-length-with-addr-base-on-stack:
12477
12478 55/push-ebp
12479 89/<- %ebp 4/r32/esp
12480
12481 (clear-stream _test-input-stream)
12482 (clear-stream $_test-input-buffered-file->buffer)
12483 (clear-stream _test-output-stream)
12484 (clear-stream $_test-output-buffered-file->buffer)
12485 (clear-stream _test-error-stream)
12486 (clear-stream $_test-error-buffered-file->buffer)
12487
12488 68/push 0/imm32
12489 68/push 0/imm32
12490 89/<- %edx 4/r32/esp
12491 (tailor-exit-descriptor %edx 0x10)
12492
12493 (write _test-input-stream "fn foo {\n")
12494 (write _test-input-stream " var a: (addr array int)\n")
12495 (write _test-input-stream " var c/ecx: (addr int) <- length a\n")
12496 (write _test-input-stream "}\n")
12497
12498 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12499
12500
12501 89/<- %edx 4/r32/esp
12502 (flush _test-output-buffered-file)
12503 (flush _test-error-buffered-file)
12504 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12510
12511 (check-stream-equal _test-output-stream "" "F - test-length-with-addr-base-on-stack: output should be empty")
12512 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: var 'a' is an addr to an array, and so must live in a register" "F - test-length-with-addr-base-on-stack: error message")
12513
12514 (check-ints-equal *(edx+4) 2 "F - test-length-with-addr-base-on-stack: exit status")
12515
12516 81 0/subop/add %esp 8/imm32
12517
12518 5d/pop-to-ebp
12519 c3/return
12520
12521 test-length-with-wrong-output-type:
12522
12523 55/push-ebp
12524 89/<- %ebp 4/r32/esp
12525
12526 (clear-stream _test-input-stream)
12527 (clear-stream $_test-input-buffered-file->buffer)
12528 (clear-stream _test-output-stream)
12529 (clear-stream $_test-output-buffered-file->buffer)
12530 (clear-stream _test-error-stream)
12531 (clear-stream $_test-error-buffered-file->buffer)
12532
12533 68/push 0/imm32
12534 68/push 0/imm32
12535 89/<- %edx 4/r32/esp
12536 (tailor-exit-descriptor %edx 0x10)
12537
12538 (write _test-input-stream "fn foo {\n")
12539 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n")
12540 (write _test-input-stream " var o/edi: (addr int) <- length a\n")
12541 (write _test-input-stream "}\n")
12542
12543 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12544
12545
12546 89/<- %edx 4/r32/esp
12547 (flush _test-output-buffered-file)
12548 (flush _test-error-buffered-file)
12549 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12555
12556 (check-stream-equal _test-output-stream "" "F - test-length-with-wrong-output-type: output should be empty")
12557 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: output 'o' does not have the right type" "F - test-length-with-wrong-output-type: error message")
12558
12559 (check-ints-equal *(edx+4) 2 "F - test-length-with-wrong-output-type: exit status")
12560
12561 81 0/subop/add %esp 8/imm32
12562
12563 5d/pop-to-ebp
12564 c3/return
12565
12566 test-length-with-wrong-output-compound-type:
12567
12568 55/push-ebp
12569 89/<- %ebp 4/r32/esp
12570
12571 (clear-stream _test-input-stream)
12572 (clear-stream $_test-input-buffered-file->buffer)
12573 (clear-stream _test-output-stream)
12574 (clear-stream $_test-output-buffered-file->buffer)
12575 (clear-stream _test-error-stream)
12576 (clear-stream $_test-error-buffered-file->buffer)
12577
12578 68/push 0/imm32
12579 68/push 0/imm32
12580 89/<- %edx 4/r32/esp
12581 (tailor-exit-descriptor %edx 0x10)
12582
12583 (write _test-input-stream "fn foo {\n")
12584 (write _test-input-stream " var a/ebx: (addr array handle boolean) <- copy 0\n")
12585 (write _test-input-stream " var o/edi: (addr handle int) <- length a\n")
12586 (write _test-input-stream "}\n")
12587
12588 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12589
12590
12591 89/<- %edx 4/r32/esp
12592 (flush _test-output-buffered-file)
12593 (flush _test-error-buffered-file)
12594 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12600
12601 (check-stream-equal _test-output-stream "" "F - test-length-with-wrong-output-compound-type: output should be empty")
12602 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: output 'o' does not have the right type" "F - test-length-with-wrong-output-compound-type: error message")
12603
12604 (check-ints-equal *(edx+4) 2 "F - test-length-with-wrong-output-compound-type: exit status")
12605
12606 81 0/subop/add %esp 8/imm32
12607
12608 5d/pop-to-ebp
12609 c3/return
12610
12611 test-length-with-no-inouts:
12612
12613 55/push-ebp
12614 89/<- %ebp 4/r32/esp
12615
12616 (clear-stream _test-input-stream)
12617 (clear-stream $_test-input-buffered-file->buffer)
12618 (clear-stream _test-output-stream)
12619 (clear-stream $_test-output-buffered-file->buffer)
12620 (clear-stream _test-error-stream)
12621 (clear-stream $_test-error-buffered-file->buffer)
12622
12623 68/push 0/imm32
12624 68/push 0/imm32
12625 89/<- %edx 4/r32/esp
12626 (tailor-exit-descriptor %edx 0x10)
12627
12628 (write _test-input-stream "fn foo {\n")
12629 (write _test-input-stream " var c/ecx: int <- length\n")
12630 (write _test-input-stream "}\n")
12631
12632 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12633
12634
12635 89/<- %edx 4/r32/esp
12636 (flush _test-output-buffered-file)
12637 (flush _test-error-buffered-file)
12638 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12644
12645 (check-stream-equal _test-output-stream "" "F - test-length-with-no-inouts: output should be empty")
12646 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: too few inouts (1 required)" "F - test-length-with-no-inouts: error message")
12647
12648 (check-ints-equal *(edx+4) 2 "F - test-length-with-no-inouts: exit status")
12649
12650 81 0/subop/add %esp 8/imm32
12651
12652 5d/pop-to-ebp
12653 c3/return
12654
12655 test-length-with-too-many-inouts:
12656
12657 55/push-ebp
12658 89/<- %ebp 4/r32/esp
12659
12660 (clear-stream _test-input-stream)
12661 (clear-stream $_test-input-buffered-file->buffer)
12662 (clear-stream _test-output-stream)
12663 (clear-stream $_test-output-buffered-file->buffer)
12664 (clear-stream _test-error-stream)
12665 (clear-stream $_test-error-buffered-file->buffer)
12666
12667 68/push 0/imm32
12668 68/push 0/imm32
12669 89/<- %edx 4/r32/esp
12670 (tailor-exit-descriptor %edx 0x10)
12671
12672 (write _test-input-stream "fn foo {\n")
12673 (write _test-input-stream " var a: (array int 3)\n")
12674 (write _test-input-stream " var c/ecx: int <- length a, 0, 0\n")
12675 (write _test-input-stream "}\n")
12676
12677 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12678
12679
12680 89/<- %edx 4/r32/esp
12681 (flush _test-output-buffered-file)
12682 (flush _test-error-buffered-file)
12683 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12689
12690 (check-stream-equal _test-output-stream "" "F - test-length-with-too-many-inouts: output should be empty")
12691 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: too many inouts (1 required)" "F - test-length-with-too-many-inouts: error message")
12692
12693 (check-ints-equal *(edx+4) 2 "F - test-length-with-too-many-inouts: exit status")
12694
12695 81 0/subop/add %esp 8/imm32
12696
12697 5d/pop-to-ebp
12698 c3/return
12699
12700 test-length-with-no-output:
12701
12702 55/push-ebp
12703 89/<- %ebp 4/r32/esp
12704
12705 (clear-stream _test-input-stream)
12706 (clear-stream $_test-input-buffered-file->buffer)
12707 (clear-stream _test-output-stream)
12708 (clear-stream $_test-output-buffered-file->buffer)
12709 (clear-stream _test-error-stream)
12710 (clear-stream $_test-error-buffered-file->buffer)
12711
12712 68/push 0/imm32
12713 68/push 0/imm32
12714 89/<- %edx 4/r32/esp
12715 (tailor-exit-descriptor %edx 0x10)
12716
12717 (write _test-input-stream "fn foo {\n")
12718 (write _test-input-stream " var a: (array int 3)\n")
12719 (write _test-input-stream " length a\n")
12720 (write _test-input-stream "}\n")
12721
12722 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12723
12724
12725 89/<- %edx 4/r32/esp
12726 (flush _test-output-buffered-file)
12727 (flush _test-error-buffered-file)
12728 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12734
12735 (check-stream-equal _test-output-stream "" "F - test-length-with-no-output: output should be empty")
12736 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: must have an output" "F - test-length-with-no-output: error message")
12737
12738 (check-ints-equal *(edx+4) 2 "F - test-length-with-no-output: exit status")
12739
12740 81 0/subop/add %esp 8/imm32
12741
12742 5d/pop-to-ebp
12743 c3/return
12744
12745 test-length-with-too-many-outputs:
12746
12747 55/push-ebp
12748 89/<- %ebp 4/r32/esp
12749
12750 (clear-stream _test-input-stream)
12751 (clear-stream $_test-input-buffered-file->buffer)
12752 (clear-stream _test-output-stream)
12753 (clear-stream $_test-output-buffered-file->buffer)
12754 (clear-stream _test-error-stream)
12755 (clear-stream $_test-error-buffered-file->buffer)
12756
12757 68/push 0/imm32
12758 68/push 0/imm32
12759 89/<- %edx 4/r32/esp
12760 (tailor-exit-descriptor %edx 0x10)
12761
12762 (write _test-input-stream "fn foo {\n")
12763 (write _test-input-stream " var a: (array int 3)\n")
12764 (write _test-input-stream " var b/eax: int <- copy 0\n")
12765 (write _test-input-stream " var c/ecx: int <- copy 0\n")
12766 (write _test-input-stream " b, c <- length a\n")
12767 (write _test-input-stream "}\n")
12768
12769 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
12770
12771
12772 89/<- %edx 4/r32/esp
12773 (flush _test-output-buffered-file)
12774 (flush _test-error-buffered-file)
12775 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
12781
12782 (check-stream-equal _test-output-stream "" "F - test-length-with-too-many-outputs: output should be empty")
12783 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: too many outputs (1 required)" "F - test-length-with-too-many-outputs: error message")
12784
12785 (check-ints-equal *(edx+4) 2 "F - test-length-with-too-many-outputs: exit status")
12786
12787 81 0/subop/add %esp 8/imm32
12788
12789 5d/pop-to-ebp
12790 c3/return
12791
12792 test-convert-function-with-return-register-and-local:
12793
12794 55/push-ebp
12795 89/<- %ebp 4/r32/esp
12796
12797 (clear-stream _test-input-stream)
12798 (clear-stream $_test-input-buffered-file->buffer)
12799 (clear-stream _test-output-stream)
12800 (clear-stream $_test-output-buffered-file->buffer)
12801
12802 (write _test-input-stream "fn foo -> _/eax: int {\n")
12803 (write _test-input-stream " var y/eax: int <- copy 3\n")
12804 (write _test-input-stream " var z/ecx: int <- copy 4\n")
12805 (write _test-input-stream " return y\n")
12806 (write _test-input-stream "}\n")
12807
12808 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
12809 (flush _test-output-buffered-file)
12810 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
12816
12817 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-register-and-local/0")
12818 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-register-and-local/1")
12819 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-register-and-local/2")
12820 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-register-and-local/3")
12821 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-register-and-local/4")
12822 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-register-and-local/5")
12823 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-return-register-and-local/6")
12824 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-convert-function-with-return-register-and-local/7")
12825 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-return-register-and-local/8")
12826 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-convert-function-with-return-register-and-local/9")
12827 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-function-with-return-register-and-local/10")
12828 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-return-register-and-local/11")
12829 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-return-register-and-local/12")
12830 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-register-and-local/13")
12831 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-register-and-local/14")
12832 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-register-and-local/15")
12833 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-register-and-local/16")
12834 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-register-and-local/17")
12835 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-register-and-local/18")
12836 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-register-and-local/19")
12837
12838 89/<- %esp 5/r32/ebp
12839 5d/pop-to-ebp
12840 c3/return
12841
12842 test-convert-function-with-return-register-and-local-2:
12843
12844 55/push-ebp
12845 89/<- %ebp 4/r32/esp
12846
12847 (clear-stream _test-input-stream)
12848 (clear-stream $_test-input-buffered-file->buffer)
12849 (clear-stream _test-output-stream)
12850 (clear-stream $_test-output-buffered-file->buffer)
12851
12852 (write _test-input-stream "fn foo -> _/eax: int {\n")
12853 (write _test-input-stream " var y/eax: int <- copy 3\n")
12854 (write _test-input-stream " var z/ecx: int <- copy 4\n")
12855 (write _test-input-stream " return z\n")
12856 (write _test-input-stream "}\n")
12857
12858 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
12859 (flush _test-output-buffered-file)
12860 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
12866
12867 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-register-and-local-2/0")
12868 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-register-and-local-2/1")
12869 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-register-and-local-2/2")
12870 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-register-and-local-2/3")
12871 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-register-and-local-2/4")
12872 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-register-and-local-2/5")
12873 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-return-register-and-local-2/6")
12874 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-convert-function-with-return-register-and-local-2/7")
12875 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-return-register-and-local-2/8")
12876 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-convert-function-with-return-register-and-local-2/9")
12877 (check-next-stream-line-equal _test-output-stream " 8b/-> %ecx 0x00000000/r32" "F - test-convert-function-with-return-register-and-local-2/10")
12878 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-return-register-and-local-2/11")
12879 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-return-register-and-local-2/12")
12880 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-register-and-local-2/13")
12881 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-register-and-local-2/14")
12882 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-register-and-local-2/15")
12883 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-register-and-local-2/16")
12884 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-register-and-local-2/17")
12885 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-register-and-local-2/18")
12886 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-register-and-local-2/19")
12887
12888 89/<- %esp 5/r32/ebp
12889 5d/pop-to-ebp
12890 c3/return
12891
12892 test-convert-function-with-return-float-register-and-local:
12893
12894 55/push-ebp
12895 89/<- %ebp 4/r32/esp
12896
12897 (clear-stream _test-input-stream)
12898 (clear-stream $_test-input-buffered-file->buffer)
12899 (clear-stream _test-output-stream)
12900 (clear-stream $_test-output-buffered-file->buffer)
12901
12902 (write _test-input-stream "fn foo -> _/xmm1: float {\n")
12903 (write _test-input-stream " var y/eax: int <- copy 3\n")
12904 (write _test-input-stream " var g/xmm0: float <- convert y\n")
12905 (write _test-input-stream " var h/xmm1: float <- convert y\n")
12906 (write _test-input-stream " return g\n")
12907 (write _test-input-stream "}\n")
12908
12909 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
12910 (flush _test-output-buffered-file)
12911 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
12917
12918 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-float-register-and-local/0")
12919 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-float-register-and-local/1")
12920 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-float-register-and-local/2")
12921 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-float-register-and-local/3")
12922 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-float-register-and-local/4")
12923 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-float-register-and-local/5")
12924 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-return-float-register-and-local/6")
12925 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-convert-function-with-return-float-register-and-local/7")
12926 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-function-with-return-float-register-and-local/8")
12927 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 0/x32" "F - test-convert-function-with-return-float-register-and-local/9")
12928 (check-next-stream-line-equal _test-output-stream " f3 0f 2a/convert-to-float %eax 0x00000000/x32" "F - test-convert-function-with-return-float-register-and-local/10")
12929 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-function-with-return-float-register-and-local/11")
12930 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-function-with-return-float-register-and-local/12")
12931 (check-next-stream-line-equal _test-output-stream " f3 0f 2a/convert-to-float %eax 0x00000001/x32" "F - test-convert-function-with-return-float-register-and-local/13")
12932 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> %xmm0 0x00000001/x32" "F - test-convert-function-with-return-float-register-and-local/14")
12933 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-dereferenced/15")
12934 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 0/x32" "F - test-convert-floating-point-dereferenced/16")
12935 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-dereferenced/17")
12936 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-return-float-register-and-local/18")
12937 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-float-register-and-local/19")
12938 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-float-register-and-local/20")
12939 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-float-register-and-local/21")
12940 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-float-register-and-local/22")
12941 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-float-register-and-local/23")
12942 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-float-register-and-local/24")
12943 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-float-register-and-local/25")
12944
12945 89/<- %esp 5/r32/ebp
12946 5d/pop-to-ebp
12947 c3/return
12948
12949 test-convert-function-with-return-and-local-vars:
12950
12951 55/push-ebp
12952 89/<- %ebp 4/r32/esp
12953
12954 (clear-stream _test-input-stream)
12955 (clear-stream $_test-input-buffered-file->buffer)
12956 (clear-stream _test-output-stream)
12957 (clear-stream $_test-output-buffered-file->buffer)
12958
12959 (write _test-input-stream "fn foo -> _/eax: int {\n")
12960 (write _test-input-stream " {\n")
12961 (write _test-input-stream " var x: int\n")
12962 (write _test-input-stream " {\n")
12963 (write _test-input-stream " var y: int\n")
12964 (write _test-input-stream " return y\n")
12965 (write _test-input-stream " increment x\n")
12966 (write _test-input-stream " }\n")
12967 (write _test-input-stream " }\n")
12968 (write _test-input-stream " return 0\n")
12969 (write _test-input-stream "}\n")
12970
12971 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
12972 (flush _test-output-buffered-file)
12973 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
12979
12980 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-and-local-vars/0")
12981 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-and-local-vars/1")
12982 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-and-local-vars/2")
12983 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-and-local-vars/3")
12984 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-and-local-vars/4")
12985 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-and-local-vars/5")
12986 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-and-local-vars/6")
12987 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-return-and-local-vars/7")
12988 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-return-and-local-vars/8")
12989 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-and-local-vars/9")
12990 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-return-and-local-vars/10")
12991 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-return-and-local-vars/11")
12992 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0xfffffff8) 0x00000000/r32" "F - test-convert-function-with-return-and-local-vars/12")
12993 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-return-and-local-vars/13")
12994 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-return-and-local-vars/14")
12995 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-and-local-vars/15")
12996 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-and-local-vars/16")
12997 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-return-and-local-vars/17")
12998 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-return-and-local-vars/18")
12999 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-and-local-vars/19")
13000 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-return-and-local-vars/20")
13001 (check-next-stream-line-equal _test-output-stream " c7 0/subop/copy %eax 0/imm32" "F - test-convert-function-with-return-and-local-vars/21")
13002 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-and-local-vars/21")
13003 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-and-local-vars/21")
13004 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-and-local-vars/22")
13005 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-and-local-vars/23")
13006 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-and-local-vars/24")
13007 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-and-local-vars/25")
13008 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-and-local-vars/26")
13009
13010 89/<- %esp 5/r32/ebp
13011 5d/pop-to-ebp
13012 c3/return
13013
13014 test-copy-object-with-no-inout:
13015
13016 55/push-ebp
13017 89/<- %ebp 4/r32/esp
13018
13019 (clear-stream _test-input-stream)
13020 (clear-stream $_test-input-buffered-file->buffer)
13021 (clear-stream _test-output-stream)
13022 (clear-stream $_test-output-buffered-file->buffer)
13023 (clear-stream _test-error-stream)
13024 (clear-stream $_test-error-buffered-file->buffer)
13025
13026 68/push 0/imm32
13027 68/push 0/imm32
13028 89/<- %edx 4/r32/esp
13029 (tailor-exit-descriptor %edx 0x10)
13030
13031 (write _test-input-stream "fn foo {\n")
13032 (write _test-input-stream " copy-object\n")
13033 (write _test-input-stream "}\n")
13034
13035 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13036
13037
13038 89/<- %edx 4/r32/esp
13039 (flush _test-output-buffered-file)
13040 (flush _test-error-buffered-file)
13041 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13047
13048 (check-stream-equal _test-output-stream "" "F - test-copy-object-with-no-inout: output should be empty")
13049 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-object' must have two inouts" "F - test-copy-object-with-no-inout: error message")
13050
13051 (check-ints-equal *(edx+4) 2 "F - test-copy-object-with-no-inout: exit status")
13052
13053 81 0/subop/add %esp 8/imm32
13054
13055 5d/pop-to-ebp
13056 c3/return
13057
13058 test-copy-object-with-no-input:
13059
13060 55/push-ebp
13061 89/<- %ebp 4/r32/esp
13062
13063 (clear-stream _test-input-stream)
13064 (clear-stream $_test-input-buffered-file->buffer)
13065 (clear-stream _test-output-stream)
13066 (clear-stream $_test-output-buffered-file->buffer)
13067 (clear-stream _test-error-stream)
13068 (clear-stream $_test-error-buffered-file->buffer)
13069
13070 68/push 0/imm32
13071 68/push 0/imm32
13072 89/<- %edx 4/r32/esp
13073 (tailor-exit-descriptor %edx 0x10)
13074
13075 (write _test-input-stream "fn foo {\n")
13076 (write _test-input-stream " var x: (addr int)\n")
13077 (write _test-input-stream " copy-object x\n")
13078 (write _test-input-stream "}\n")
13079
13080 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13081
13082
13083 89/<- %edx 4/r32/esp
13084 (flush _test-output-buffered-file)
13085 (flush _test-error-buffered-file)
13086 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13092
13093 (check-stream-equal _test-output-stream "" "F - test-copy-object-with-no-input: output should be empty")
13094 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-object' must have two inouts" "F - test-copy-object-with-no-input: error message")
13095
13096 (check-ints-equal *(edx+4) 2 "F - test-copy-object-with-no-input: exit status")
13097
13098 81 0/subop/add %esp 8/imm32
13099
13100 5d/pop-to-ebp
13101 c3/return
13102
13103 test-copy-object-with-too-many-inouts:
13104
13105 55/push-ebp
13106 89/<- %ebp 4/r32/esp
13107
13108 (clear-stream _test-input-stream)
13109 (clear-stream $_test-input-buffered-file->buffer)
13110 (clear-stream _test-output-stream)
13111 (clear-stream $_test-output-buffered-file->buffer)
13112 (clear-stream _test-error-stream)
13113 (clear-stream $_test-error-buffered-file->buffer)
13114
13115 68/push 0/imm32
13116 68/push 0/imm32
13117 89/<- %edx 4/r32/esp
13118 (tailor-exit-descriptor %edx 0x10)
13119
13120 (write _test-input-stream "fn foo {\n")
13121 (write _test-input-stream " var x: (addr boolean)\n")
13122 (write _test-input-stream " copy-object x, x, x\n")
13123 (write _test-input-stream "}\n")
13124
13125 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13126
13127
13128 89/<- %edx 4/r32/esp
13129 (flush _test-output-buffered-file)
13130 (flush _test-error-buffered-file)
13131 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13137
13138 (check-stream-equal _test-output-stream "" "F - test-copy-object-with-too-many-inouts: output should be empty")
13139 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-object' must have two inouts" "F - test-copy-object-with-too-many-inouts: error message")
13140
13141 (check-ints-equal *(edx+4) 2 "F - test-copy-object-with-too-many-inouts: exit status")
13142
13143 81 0/subop/add %esp 8/imm32
13144
13145 5d/pop-to-ebp
13146 c3/return
13147
13148 test-copy-object-with-output:
13149
13150 55/push-ebp
13151 89/<- %ebp 4/r32/esp
13152
13153 (clear-stream _test-input-stream)
13154 (clear-stream $_test-input-buffered-file->buffer)
13155 (clear-stream _test-output-stream)
13156 (clear-stream $_test-output-buffered-file->buffer)
13157 (clear-stream _test-error-stream)
13158 (clear-stream $_test-error-buffered-file->buffer)
13159
13160 68/push 0/imm32
13161 68/push 0/imm32
13162 89/<- %edx 4/r32/esp
13163 (tailor-exit-descriptor %edx 0x10)
13164
13165 (write _test-input-stream "fn foo {\n")
13166 (write _test-input-stream " var x/eax: (addr boolean) <- copy 0\n")
13167 (write _test-input-stream " var y/ecx: (addr boolean) <- copy 0\n")
13168 (write _test-input-stream " x <- copy-object x, y\n")
13169 (write _test-input-stream "}\n")
13170
13171 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13172
13173
13174 89/<- %edx 4/r32/esp
13175 (flush _test-output-buffered-file)
13176 (flush _test-error-buffered-file)
13177 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13183
13184 (check-stream-equal _test-output-stream "" "F - test-copy-object-with-output: output should be empty")
13185 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-object' must not have any outputs" "F - test-copy-object-with-output: error message")
13186
13187 (check-ints-equal *(edx+4) 2 "F - test-copy-object-with-output: exit status")
13188
13189 81 0/subop/add %esp 8/imm32
13190
13191 5d/pop-to-ebp
13192 c3/return
13193
13194 test-copy-object-deref-address:
13195
13196 55/push-ebp
13197 89/<- %ebp 4/r32/esp
13198
13199 (clear-stream _test-input-stream)
13200 (clear-stream $_test-input-buffered-file->buffer)
13201 (clear-stream _test-output-stream)
13202 (clear-stream $_test-output-buffered-file->buffer)
13203
13204 (write _test-input-stream "fn foo {\n")
13205 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n")
13206 (write _test-input-stream " var y/ecx: (addr addr int) <- copy 0\n")
13207 (write _test-input-stream " copy-object *y, x\n")
13208 (write _test-input-stream "}\n")
13209
13210 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
13211 (flush _test-output-buffered-file)
13212 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13218
13219 (check-next-stream-line-equal _test-error-stream "" "F - test-copy-object-deref-address: error message")
13220
13221 5d/pop-to-ebp
13222 c3/return
13223
13224 test-copy-object-non-addr:
13225
13226 55/push-ebp
13227 89/<- %ebp 4/r32/esp
13228
13229 (clear-stream _test-input-stream)
13230 (clear-stream $_test-input-buffered-file->buffer)
13231 (clear-stream _test-output-stream)
13232 (clear-stream $_test-output-buffered-file->buffer)
13233 (clear-stream _test-error-stream)
13234 (clear-stream $_test-error-buffered-file->buffer)
13235
13236 68/push 0/imm32
13237 68/push 0/imm32
13238 89/<- %edx 4/r32/esp
13239 (tailor-exit-descriptor %edx 0x10)
13240
13241 (write _test-input-stream "fn foo {\n")
13242 (write _test-input-stream " var x: int\n")
13243 (write _test-input-stream " var y: int\n")
13244 (write _test-input-stream " copy-object y, x\n")
13245 (write _test-input-stream "}\n")
13246
13247 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13248
13249
13250 89/<- %edx 4/r32/esp
13251 (flush _test-output-buffered-file)
13252 (flush _test-error-buffered-file)
13253 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13259
13260 (check-stream-equal _test-output-stream "" "F - test-copy-object-non-addr: output should be empty")
13261 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-object: two inouts with identical addr types expected" "F - test-copy-object-non-addr: error message")
13262
13263 (check-ints-equal *(edx+4) 2 "F - test-copy-object-non-addr: exit status")
13264
13265 81 0/subop/add %esp 8/imm32
13266
13267 5d/pop-to-ebp
13268 c3/return
13269
13270 test-copy-object-non-equal:
13271
13272 55/push-ebp
13273 89/<- %ebp 4/r32/esp
13274
13275 (clear-stream _test-input-stream)
13276 (clear-stream $_test-input-buffered-file->buffer)
13277 (clear-stream _test-output-stream)
13278 (clear-stream $_test-output-buffered-file->buffer)
13279 (clear-stream _test-error-stream)
13280 (clear-stream $_test-error-buffered-file->buffer)
13281
13282 68/push 0/imm32
13283 68/push 0/imm32
13284 89/<- %edx 4/r32/esp
13285 (tailor-exit-descriptor %edx 0x10)
13286
13287 (write _test-input-stream "fn foo {\n")
13288 (write _test-input-stream " var x: (addr int)\n")
13289 (write _test-input-stream " var y: (addr boolean)\n")
13290 (write _test-input-stream " copy-object y, x\n")
13291 (write _test-input-stream "}\n")
13292
13293 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13294
13295
13296 89/<- %edx 4/r32/esp
13297 (flush _test-output-buffered-file)
13298 (flush _test-error-buffered-file)
13299 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13305
13306 (check-stream-equal _test-output-stream "" "F - test-copy-object-non-equal: output should be empty")
13307 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-object: two inouts with identical addr types expected" "F - test-copy-object-non-equal: error message")
13308
13309 (check-ints-equal *(edx+4) 2 "F - test-copy-object-non-equal: exit status")
13310
13311 81 0/subop/add %esp 8/imm32
13312
13313 5d/pop-to-ebp
13314 c3/return
13315
13316 test-allocate-with-no-inout:
13317
13318 55/push-ebp
13319 89/<- %ebp 4/r32/esp
13320
13321 (clear-stream _test-input-stream)
13322 (clear-stream $_test-input-buffered-file->buffer)
13323 (clear-stream _test-output-stream)
13324 (clear-stream $_test-output-buffered-file->buffer)
13325 (clear-stream _test-error-stream)
13326 (clear-stream $_test-error-buffered-file->buffer)
13327
13328 68/push 0/imm32
13329 68/push 0/imm32
13330 89/<- %edx 4/r32/esp
13331 (tailor-exit-descriptor %edx 0x10)
13332
13333 (write _test-input-stream "fn foo {\n")
13334 (write _test-input-stream " allocate\n")
13335 (write _test-input-stream "}\n")
13336
13337 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13338
13339
13340 89/<- %edx 4/r32/esp
13341 (flush _test-output-buffered-file)
13342 (flush _test-error-buffered-file)
13343 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13349
13350 (check-stream-equal _test-output-stream "" "F - test-allocate-with-no-inout: output should be empty")
13351 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'allocate' must have a single inout" "F - test-allocate-with-no-inout: error message")
13352
13353 (check-ints-equal *(edx+4) 2 "F - test-allocate-with-no-inout: exit status")
13354
13355 81 0/subop/add %esp 8/imm32
13356
13357 5d/pop-to-ebp
13358 c3/return
13359
13360 test-allocate-with-too-many-inouts:
13361
13362 55/push-ebp
13363 89/<- %ebp 4/r32/esp
13364
13365 (clear-stream _test-input-stream)
13366 (clear-stream $_test-input-buffered-file->buffer)
13367 (clear-stream _test-output-stream)
13368 (clear-stream $_test-output-buffered-file->buffer)
13369 (clear-stream _test-error-stream)
13370 (clear-stream $_test-error-buffered-file->buffer)
13371
13372 68/push 0/imm32
13373 68/push 0/imm32
13374 89/<- %edx 4/r32/esp
13375 (tailor-exit-descriptor %edx 0x10)
13376
13377 (write _test-input-stream "fn foo {\n")
13378 (write _test-input-stream " var x: (addr handle int)\n")
13379 (write _test-input-stream " allocate x, 0\n")
13380 (write _test-input-stream "}\n")
13381
13382 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13383
13384
13385 89/<- %edx 4/r32/esp
13386 (flush _test-output-buffered-file)
13387 (flush _test-error-buffered-file)
13388 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13394
13395 (check-stream-equal _test-output-stream "" "F - test-allocate-with-too-many-inouts: output should be empty")
13396 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'allocate' must have a single inout" "F - test-allocate-with-too-many-inouts: error message")
13397
13398 (check-ints-equal *(edx+4) 2 "F - test-allocate-with-too-many-inouts: exit status")
13399
13400 81 0/subop/add %esp 8/imm32
13401
13402 5d/pop-to-ebp
13403 c3/return
13404
13405 test-allocate-with-output:
13406
13407 55/push-ebp
13408 89/<- %ebp 4/r32/esp
13409
13410 (clear-stream _test-input-stream)
13411 (clear-stream $_test-input-buffered-file->buffer)
13412 (clear-stream _test-output-stream)
13413 (clear-stream $_test-output-buffered-file->buffer)
13414 (clear-stream _test-error-stream)
13415 (clear-stream $_test-error-buffered-file->buffer)
13416
13417 68/push 0/imm32
13418 68/push 0/imm32
13419 89/<- %edx 4/r32/esp
13420 (tailor-exit-descriptor %edx 0x10)
13421
13422 (write _test-input-stream "fn foo {\n")
13423 (write _test-input-stream " var x/eax: boolean <- copy 0\n")
13424 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n")
13425 (write _test-input-stream " x <- allocate y\n")
13426 (write _test-input-stream "}\n")
13427
13428 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13429
13430
13431 89/<- %edx 4/r32/esp
13432 (flush _test-output-buffered-file)
13433 (flush _test-error-buffered-file)
13434 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13440
13441 (check-stream-equal _test-output-stream "" "F - test-allocate-with-output: output should be empty")
13442 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'allocate' must not have any outputs" "F - test-allocate-with-output: error message")
13443
13444 (check-ints-equal *(edx+4) 2 "F - test-allocate-with-output: exit status")
13445
13446 81 0/subop/add %esp 8/imm32
13447
13448 5d/pop-to-ebp
13449 c3/return
13450
13451 test-allocate-non-addr:
13452
13453 55/push-ebp
13454 89/<- %ebp 4/r32/esp
13455
13456 (clear-stream _test-input-stream)
13457 (clear-stream $_test-input-buffered-file->buffer)
13458 (clear-stream _test-output-stream)
13459 (clear-stream $_test-output-buffered-file->buffer)
13460 (clear-stream _test-error-stream)
13461 (clear-stream $_test-error-buffered-file->buffer)
13462
13463 68/push 0/imm32
13464 68/push 0/imm32
13465 89/<- %edx 4/r32/esp
13466 (tailor-exit-descriptor %edx 0x10)
13467
13468 (write _test-input-stream "fn foo {\n")
13469 (write _test-input-stream " var y: (handle int)\n")
13470 (write _test-input-stream " allocate y\n")
13471 (write _test-input-stream "}\n")
13472
13473 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13474
13475
13476 89/<- %edx 4/r32/esp
13477 (flush _test-output-buffered-file)
13478 (flush _test-error-buffered-file)
13479 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13485
13486 (check-stream-equal _test-output-stream "" "F - test-allocate-non-addr: output must be empty")
13487 (check-next-stream-line-equal _test-error-stream "fn foo: stmt allocate: inout 'y' must have type (addr handle ...)" "F - test-allocate-non-addr: error message")
13488
13489 (check-ints-equal *(edx+4) 2 "F - test-allocate-non-addr: exit status")
13490
13491 81 0/subop/add %esp 8/imm32
13492
13493 5d/pop-to-ebp
13494 c3/return
13495
13496 test-allocate-non-addr-handle:
13497
13498 55/push-ebp
13499 89/<- %ebp 4/r32/esp
13500
13501 (clear-stream _test-input-stream)
13502 (clear-stream $_test-input-buffered-file->buffer)
13503 (clear-stream _test-output-stream)
13504 (clear-stream $_test-output-buffered-file->buffer)
13505 (clear-stream _test-error-stream)
13506 (clear-stream $_test-error-buffered-file->buffer)
13507
13508 68/push 0/imm32
13509 68/push 0/imm32
13510 89/<- %edx 4/r32/esp
13511 (tailor-exit-descriptor %edx 0x10)
13512
13513 (write _test-input-stream "fn foo {\n")
13514 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n")
13515 (write _test-input-stream " allocate y\n")
13516 (write _test-input-stream "}\n")
13517
13518 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13519
13520
13521 89/<- %edx 4/r32/esp
13522 (flush _test-output-buffered-file)
13523 (flush _test-error-buffered-file)
13524 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13530
13531 (check-stream-equal _test-output-stream "" "F - test-allocate-non-addr-handle: output should be empty")
13532 (check-next-stream-line-equal _test-error-stream "fn foo: stmt allocate: inout 'y' must have type (addr handle ...)" "F - test-allocate-non-addr-handle: error message")
13533
13534 (check-ints-equal *(edx+4) 2 "F - test-allocate-non-addr-handle: exit status")
13535
13536 81 0/subop/add %esp 8/imm32
13537
13538 5d/pop-to-ebp
13539 c3/return
13540
13541 test-allocate-deref-address:
13542
13543 55/push-ebp
13544 89/<- %ebp 4/r32/esp
13545
13546 (clear-stream _test-input-stream)
13547 (clear-stream $_test-input-buffered-file->buffer)
13548 (clear-stream _test-output-stream)
13549 (clear-stream $_test-output-buffered-file->buffer)
13550
13551 (write _test-input-stream "fn foo {\n")
13552 (write _test-input-stream " var y/ecx: (addr addr handle int) <- copy 0\n")
13553 (write _test-input-stream " allocate *y\n")
13554 (write _test-input-stream "}\n")
13555
13556 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
13557 (flush _test-output-buffered-file)
13558 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13564
13565 (check-next-stream-line-equal _test-error-stream "" "F - test-allocate-deref-address: error message")
13566
13567 5d/pop-to-ebp
13568 c3/return
13569
13570 test-populate-with-no-inout:
13571
13572 55/push-ebp
13573 89/<- %ebp 4/r32/esp
13574
13575 (clear-stream _test-input-stream)
13576 (clear-stream $_test-input-buffered-file->buffer)
13577 (clear-stream _test-output-stream)
13578 (clear-stream $_test-output-buffered-file->buffer)
13579 (clear-stream _test-error-stream)
13580 (clear-stream $_test-error-buffered-file->buffer)
13581
13582 68/push 0/imm32
13583 68/push 0/imm32
13584 89/<- %edx 4/r32/esp
13585 (tailor-exit-descriptor %edx 0x10)
13586
13587 (write _test-input-stream "fn foo {\n")
13588 (write _test-input-stream " populate\n")
13589 (write _test-input-stream "}\n")
13590
13591 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13592
13593
13594 89/<- %edx 4/r32/esp
13595 (flush _test-output-buffered-file)
13596 (flush _test-error-buffered-file)
13597 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13603
13604 (check-stream-equal _test-output-stream "" "F - test-populate-with-no-inout: output should be empty")
13605 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate' must have two inouts" "F - test-populate-with-no-inout: error message")
13606
13607 (check-ints-equal *(edx+4) 2 "F - test-populate-with-no-inout: exit status")
13608
13609 81 0/subop/add %esp 8/imm32
13610
13611 5d/pop-to-ebp
13612 c3/return
13613
13614 test-populate-with-too-many-inouts:
13615
13616 55/push-ebp
13617 89/<- %ebp 4/r32/esp
13618
13619 (clear-stream _test-input-stream)
13620 (clear-stream $_test-input-buffered-file->buffer)
13621 (clear-stream _test-output-stream)
13622 (clear-stream $_test-output-buffered-file->buffer)
13623 (clear-stream _test-error-stream)
13624 (clear-stream $_test-error-buffered-file->buffer)
13625
13626 68/push 0/imm32
13627 68/push 0/imm32
13628 89/<- %edx 4/r32/esp
13629 (tailor-exit-descriptor %edx 0x10)
13630
13631 (write _test-input-stream "fn foo {\n")
13632 (write _test-input-stream " var x: (addr handle int)\n")
13633 (write _test-input-stream " populate x, 3, 0\n")
13634 (write _test-input-stream "}\n")
13635
13636 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13637
13638
13639 89/<- %edx 4/r32/esp
13640 (flush _test-output-buffered-file)
13641 (flush _test-error-buffered-file)
13642 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13648
13649 (check-stream-equal _test-output-stream "" "F - test-populate-with-too-many-inouts: output should be empty")
13650 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate' must have two inouts" "F - test-populate-with-too-many-inouts: error message")
13651
13652 (check-ints-equal *(edx+4) 2 "F - test-populate-with-too-many-inouts: exit status")
13653
13654 81 0/subop/add %esp 8/imm32
13655
13656 5d/pop-to-ebp
13657 c3/return
13658
13659 test-populate-with-output:
13660
13661 55/push-ebp
13662 89/<- %ebp 4/r32/esp
13663
13664 (clear-stream _test-input-stream)
13665 (clear-stream $_test-input-buffered-file->buffer)
13666 (clear-stream _test-output-stream)
13667 (clear-stream $_test-output-buffered-file->buffer)
13668 (clear-stream _test-error-stream)
13669 (clear-stream $_test-error-buffered-file->buffer)
13670
13671 68/push 0/imm32
13672 68/push 0/imm32
13673 89/<- %edx 4/r32/esp
13674 (tailor-exit-descriptor %edx 0x10)
13675
13676 (write _test-input-stream "fn foo {\n")
13677 (write _test-input-stream " var x/eax: boolean <- copy 0\n")
13678 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n")
13679 (write _test-input-stream " x <- populate y\n")
13680 (write _test-input-stream "}\n")
13681
13682 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13683
13684
13685 89/<- %edx 4/r32/esp
13686 (flush _test-output-buffered-file)
13687 (flush _test-error-buffered-file)
13688 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13694
13695 (check-stream-equal _test-output-stream "" "F - test-populate-with-output: output should be empty")
13696 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate' must not have any outputs" "F - test-populate-with-output: error message")
13697
13698 (check-ints-equal *(edx+4) 2 "F - test-populate-with-output: exit status")
13699
13700 81 0/subop/add %esp 8/imm32
13701
13702 5d/pop-to-ebp
13703 c3/return
13704
13705 test-populate-non-addr:
13706
13707 55/push-ebp
13708 89/<- %ebp 4/r32/esp
13709
13710 (clear-stream _test-input-stream)
13711 (clear-stream $_test-input-buffered-file->buffer)
13712 (clear-stream _test-output-stream)
13713 (clear-stream $_test-output-buffered-file->buffer)
13714 (clear-stream _test-error-stream)
13715 (clear-stream $_test-error-buffered-file->buffer)
13716
13717 68/push 0/imm32
13718 68/push 0/imm32
13719 89/<- %edx 4/r32/esp
13720 (tailor-exit-descriptor %edx 0x10)
13721
13722 (write _test-input-stream "fn foo {\n")
13723 (write _test-input-stream " var y: (handle int)\n")
13724 (write _test-input-stream " populate y, 3\n")
13725 (write _test-input-stream "}\n")
13726
13727 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13728
13729
13730 89/<- %edx 4/r32/esp
13731 (flush _test-output-buffered-file)
13732 (flush _test-error-buffered-file)
13733 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13739
13740 (check-stream-equal _test-output-stream "" "F - test-populate-non-addr: output must be empty")
13741 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate: first inout 'y' must have type (addr handle array ...)" "F - test-populate-non-addr: error message")
13742
13743 (check-ints-equal *(edx+4) 2 "F - test-populate-non-addr: exit status")
13744
13745 81 0/subop/add %esp 8/imm32
13746
13747 5d/pop-to-ebp
13748 c3/return
13749
13750 test-populate-non-addr-handle:
13751
13752 55/push-ebp
13753 89/<- %ebp 4/r32/esp
13754
13755 (clear-stream _test-input-stream)
13756 (clear-stream $_test-input-buffered-file->buffer)
13757 (clear-stream _test-output-stream)
13758 (clear-stream $_test-output-buffered-file->buffer)
13759 (clear-stream _test-error-stream)
13760 (clear-stream $_test-error-buffered-file->buffer)
13761
13762 68/push 0/imm32
13763 68/push 0/imm32
13764 89/<- %edx 4/r32/esp
13765 (tailor-exit-descriptor %edx 0x10)
13766
13767 (write _test-input-stream "fn foo {\n")
13768 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n")
13769 (write _test-input-stream " populate y, 3\n")
13770 (write _test-input-stream "}\n")
13771
13772 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13773
13774
13775 89/<- %edx 4/r32/esp
13776 (flush _test-output-buffered-file)
13777 (flush _test-error-buffered-file)
13778 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13784
13785 (check-stream-equal _test-output-stream "" "F - test-populate-non-addr-handle: output should be empty")
13786 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate: first inout 'y' must have type (addr handle array ...)" "F - test-populate-non-addr-handle: error message")
13787
13788 (check-ints-equal *(edx+4) 2 "F - test-populate-non-addr-handle: exit status")
13789
13790 81 0/subop/add %esp 8/imm32
13791
13792 5d/pop-to-ebp
13793 c3/return
13794
13795 test-populate-non-addr-handle-array:
13796
13797 55/push-ebp
13798 89/<- %ebp 4/r32/esp
13799
13800 (clear-stream _test-input-stream)
13801 (clear-stream $_test-input-buffered-file->buffer)
13802 (clear-stream _test-output-stream)
13803 (clear-stream $_test-output-buffered-file->buffer)
13804 (clear-stream _test-error-stream)
13805 (clear-stream $_test-error-buffered-file->buffer)
13806
13807 68/push 0/imm32
13808 68/push 0/imm32
13809 89/<- %edx 4/r32/esp
13810 (tailor-exit-descriptor %edx 0x10)
13811
13812 (write _test-input-stream "fn foo {\n")
13813 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n")
13814 (write _test-input-stream " populate y, 3\n")
13815 (write _test-input-stream "}\n")
13816
13817 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13818
13819
13820 89/<- %edx 4/r32/esp
13821 (flush _test-output-buffered-file)
13822 (flush _test-error-buffered-file)
13823 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13829
13830 (check-stream-equal _test-output-stream "" "F - test-populate-non-addr-handle-array: output should be empty")
13831 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate: first inout 'y' must have type (addr handle array ...)" "F - test-populate-non-addr-handle-array: error message")
13832
13833 (check-ints-equal *(edx+4) 2 "F - test-populate-non-addr-handle-array: exit status")
13834
13835 81 0/subop/add %esp 8/imm32
13836
13837 5d/pop-to-ebp
13838 c3/return
13839
13840 test-populate-deref-address:
13841
13842 55/push-ebp
13843 89/<- %ebp 4/r32/esp
13844
13845 (clear-stream _test-input-stream)
13846 (clear-stream $_test-input-buffered-file->buffer)
13847 (clear-stream _test-output-stream)
13848 (clear-stream $_test-output-buffered-file->buffer)
13849
13850 (write _test-input-stream "fn foo {\n")
13851 (write _test-input-stream " var y/ecx: (addr addr handle array int) <- copy 0\n")
13852 (write _test-input-stream " populate *y, 3\n")
13853 (write _test-input-stream "}\n")
13854
13855 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
13856 (flush _test-output-buffered-file)
13857 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13863
13864 (check-next-stream-line-equal _test-error-stream "" "F - test-populate-deref-address: error message")
13865
13866 5d/pop-to-ebp
13867 c3/return
13868
13869 test-populate-stream-with-no-inout:
13870
13871 55/push-ebp
13872 89/<- %ebp 4/r32/esp
13873
13874 (clear-stream _test-input-stream)
13875 (clear-stream $_test-input-buffered-file->buffer)
13876 (clear-stream _test-output-stream)
13877 (clear-stream $_test-output-buffered-file->buffer)
13878 (clear-stream _test-error-stream)
13879 (clear-stream $_test-error-buffered-file->buffer)
13880
13881 68/push 0/imm32
13882 68/push 0/imm32
13883 89/<- %edx 4/r32/esp
13884 (tailor-exit-descriptor %edx 0x10)
13885
13886 (write _test-input-stream "fn foo {\n")
13887 (write _test-input-stream " populate-stream\n")
13888 (write _test-input-stream "}\n")
13889
13890 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13891
13892
13893 89/<- %edx 4/r32/esp
13894 (flush _test-output-buffered-file)
13895 (flush _test-error-buffered-file)
13896 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13902
13903 (check-stream-equal _test-output-stream "" "F - test-populate-stream-with-no-inout: output should be empty")
13904 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate-stream' must have two inouts" "F - test-populate-stream-with-no-inout: error message")
13905
13906 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-with-no-inout: exit status")
13907
13908 81 0/subop/add %esp 8/imm32
13909
13910 5d/pop-to-ebp
13911 c3/return
13912
13913 test-populate-stream-with-too-many-inouts:
13914
13915 55/push-ebp
13916 89/<- %ebp 4/r32/esp
13917
13918 (clear-stream _test-input-stream)
13919 (clear-stream $_test-input-buffered-file->buffer)
13920 (clear-stream _test-output-stream)
13921 (clear-stream $_test-output-buffered-file->buffer)
13922 (clear-stream _test-error-stream)
13923 (clear-stream $_test-error-buffered-file->buffer)
13924
13925 68/push 0/imm32
13926 68/push 0/imm32
13927 89/<- %edx 4/r32/esp
13928 (tailor-exit-descriptor %edx 0x10)
13929
13930 (write _test-input-stream "fn foo {\n")
13931 (write _test-input-stream " var x: (addr handle int)\n")
13932 (write _test-input-stream " populate-stream x, 3, 0\n")
13933 (write _test-input-stream "}\n")
13934
13935 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13936
13937
13938 89/<- %edx 4/r32/esp
13939 (flush _test-output-buffered-file)
13940 (flush _test-error-buffered-file)
13941 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13947
13948 (check-stream-equal _test-output-stream "" "F - test-populate-stream-with-too-many-inouts: output should be empty")
13949 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate-stream' must have two inouts" "F - test-populate-stream-with-too-many-inouts: error message")
13950
13951 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-with-too-many-inouts: exit status")
13952
13953 81 0/subop/add %esp 8/imm32
13954
13955 5d/pop-to-ebp
13956 c3/return
13957
13958 test-populate-stream-with-output:
13959
13960 55/push-ebp
13961 89/<- %ebp 4/r32/esp
13962
13963 (clear-stream _test-input-stream)
13964 (clear-stream $_test-input-buffered-file->buffer)
13965 (clear-stream _test-output-stream)
13966 (clear-stream $_test-output-buffered-file->buffer)
13967 (clear-stream _test-error-stream)
13968 (clear-stream $_test-error-buffered-file->buffer)
13969
13970 68/push 0/imm32
13971 68/push 0/imm32
13972 89/<- %edx 4/r32/esp
13973 (tailor-exit-descriptor %edx 0x10)
13974
13975 (write _test-input-stream "fn foo {\n")
13976 (write _test-input-stream " var x/eax: boolean <- copy 0\n")
13977 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n")
13978 (write _test-input-stream " x <- populate-stream y\n")
13979 (write _test-input-stream "}\n")
13980
13981 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
13982
13983
13984 89/<- %edx 4/r32/esp
13985 (flush _test-output-buffered-file)
13986 (flush _test-error-buffered-file)
13987 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
13993
13994 (check-stream-equal _test-output-stream "" "F - test-populate-stream-with-output: output should be empty")
13995 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate-stream' must not have any outputs" "F - test-populate-stream-with-output: error message")
13996
13997 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-with-output: exit status")
13998
13999 81 0/subop/add %esp 8/imm32
14000
14001 5d/pop-to-ebp
14002 c3/return
14003
14004 test-populate-stream-non-addr:
14005
14006 55/push-ebp
14007 89/<- %ebp 4/r32/esp
14008
14009 (clear-stream _test-input-stream)
14010 (clear-stream $_test-input-buffered-file->buffer)
14011 (clear-stream _test-output-stream)
14012 (clear-stream $_test-output-buffered-file->buffer)
14013 (clear-stream _test-error-stream)
14014 (clear-stream $_test-error-buffered-file->buffer)
14015
14016 68/push 0/imm32
14017 68/push 0/imm32
14018 89/<- %edx 4/r32/esp
14019 (tailor-exit-descriptor %edx 0x10)
14020
14021 (write _test-input-stream "fn foo {\n")
14022 (write _test-input-stream " var y: (handle int)\n")
14023 (write _test-input-stream " populate-stream y, 3\n")
14024 (write _test-input-stream "}\n")
14025
14026 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
14027
14028
14029 89/<- %edx 4/r32/esp
14030 (flush _test-output-buffered-file)
14031 (flush _test-error-buffered-file)
14032 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
14038
14039 (check-stream-equal _test-output-stream "" "F - test-populate-stream-non-addr: output must be empty")
14040 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate-stream: first inout 'y' must have type (addr handle stream ...)" "F - test-populate-stream-non-addr: error message")
14041
14042 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-non-addr: exit status")
14043
14044 81 0/subop/add %esp 8/imm32
14045
14046 5d/pop-to-ebp
14047 c3/return
14048
14049 test-populate-stream-non-addr-handle:
14050
14051 55/push-ebp
14052 89/<- %ebp 4/r32/esp
14053
14054 (clear-stream _test-input-stream)
14055 (clear-stream $_test-input-buffered-file->buffer)
14056 (clear-stream _test-output-stream)
14057 (clear-stream $_test-output-buffered-file->buffer)
14058 (clear-stream _test-error-stream)
14059 (clear-stream $_test-error-buffered-file->buffer)
14060
14061 68/push 0/imm32
14062 68/push 0/imm32
14063 89/<- %edx 4/r32/esp
14064 (tailor-exit-descriptor %edx 0x10)
14065
14066 (write _test-input-stream "fn foo {\n")
14067 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n")
14068 (write _test-input-stream " populate-stream y, 3\n")
14069 (write _test-input-stream "}\n")
14070
14071 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
14072
14073
14074 89/<- %edx 4/r32/esp
14075 (flush _test-output-buffered-file)
14076 (flush _test-error-buffered-file)
14077 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
14083
14084 (check-stream-equal _test-output-stream "" "F - test-populate-stream-non-addr-handle: output should be empty")
14085 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate-stream: first inout 'y' must have type (addr handle stream ...)" "F - test-populate-stream-non-addr-handle: error message")
14086
14087 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-non-addr-handle: exit status")
14088
14089 81 0/subop/add %esp 8/imm32
14090
14091 5d/pop-to-ebp
14092 c3/return
14093
14094 test-populate-stream-non-addr-handle-stream:
14095
14096 55/push-ebp
14097 89/<- %ebp 4/r32/esp
14098
14099 (clear-stream _test-input-stream)
14100 (clear-stream $_test-input-buffered-file->buffer)
14101 (clear-stream _test-output-stream)
14102 (clear-stream $_test-output-buffered-file->buffer)
14103 (clear-stream _test-error-stream)
14104 (clear-stream $_test-error-buffered-file->buffer)
14105
14106 68/push 0/imm32
14107 68/push 0/imm32
14108 89/<- %edx 4/r32/esp
14109 (tailor-exit-descriptor %edx 0x10)
14110
14111 (write _test-input-stream "fn foo {\n")
14112 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n")
14113 (write _test-input-stream " populate-stream y, 3\n")
14114 (write _test-input-stream "}\n")
14115
14116 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx)
14117
14118
14119 89/<- %edx 4/r32/esp
14120 (flush _test-output-buffered-file)
14121 (flush _test-error-buffered-file)
14122 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
14128
14129 (check-stream-equal _test-output-stream "" "F - test-populate-stream-non-addr-handle-stream: output should be empty")
14130 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate-stream: first inout 'y' must have type (addr handle stream ...)" "F - test-populate-stream-non-addr-handle-stream: error message")
14131
14132 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-non-addr-handle-stream: exit status")
14133
14134 81 0/subop/add %esp 8/imm32
14135
14136 5d/pop-to-ebp
14137 c3/return
14138
14139 test-populate-stream-deref-address:
14140
14141 55/push-ebp
14142 89/<- %ebp 4/r32/esp
14143
14144 (clear-stream _test-input-stream)
14145 (clear-stream $_test-input-buffered-file->buffer)
14146 (clear-stream _test-output-stream)
14147 (clear-stream $_test-output-buffered-file->buffer)
14148
14149 (write _test-input-stream "fn foo {\n")
14150 (write _test-input-stream " var y/ecx: (addr addr handle stream int) <- copy 0\n")
14151 (write _test-input-stream " populate-stream *y, 3\n")
14152 (write _test-input-stream "}\n")
14153
14154 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0)
14155 (flush _test-output-buffered-file)
14156 +-- 6 lines: #? # dump _test-error-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
14162
14163 (check-next-stream-line-equal _test-error-stream "" "F - test-populate-stream-deref-address: error message")
14164
14165 5d/pop-to-ebp
14166 c3/return
14167
14168
14169
14170
14171
14172 == data
14173
14174
14175 Next-block-index:
14176 1/imm32
14177
14178 Curr-block-depth:
14179 1/imm32
14180
14181 == code
14182
14183 parse-mu:
14184
14185
14186
14187
14188
14189
14190
14191
14192
14193
14194
14195
14196
14197
14198
14199
14200
14201
14202
14203
14204
14205
14206
14207
14208
14209
14210
14211
14212
14213
14214
14215
14216
14217
14218
14219
14220
14221
14222 55/push-ebp
14223 89/<- %ebp 4/r32/esp
14224
14225 68/push _Program-signatures/imm32
14226
14227 50/push-eax
14228 51/push-ecx
14229 52/push-edx
14230 53/push-ebx
14231 56/push-esi
14232 57/push-edi
14233
14234 81 5/subop/subtract %esp 0x200/imm32
14235 68/push 0x200/imm32/size
14236 68/push 0/imm32/read
14237 68/push 0/imm32/write
14238 89/<- %ecx 4/r32/esp
14239
14240 68/push 0/imm32/end
14241 68/push 0/imm32/start
14242 89/<- %edx 4/r32/esp
14243
14244 bf/copy-to-edi _Program-functions/imm32
14245
14246 81 5/subop/subtract %esp 0xc00/imm32
14247 68/push 0xc00/imm32/size
14248 68/push 0/imm32/top
14249 89/<- %ebx 4/r32/esp
14250 {
14251 $parse-mu:line-loop:
14252 (clear-stream %ecx)
14253 (read-line-buffered *(ebp+8) %ecx)
14254
14255 81 7/subop/compare *ecx 0/imm32
14256 0f 84/jump-if-= break/disp32
14257 +-- 6 lines: #? # dump line ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
14263 (next-mu-token %ecx %edx)
14264
14265 (slice-empty? %edx)
14266 3d/compare-eax-and 0/imm32/false
14267 0f 85/jump-if-!= loop/disp32
14268
14269
14270 8b/-> *edx 0/r32/eax
14271 8a/copy-byte *eax 0/r32/AL
14272 81 4/subop/and %eax 0xff/imm32
14273
14274 3d/compare-eax-and 0x23/imm32/hash
14275 0f 84/jump-if-= loop/disp32
14276
14277 {
14278 $parse-mu:fn:
14279 (slice-equal? %edx "fn")
14280 3d/compare-eax-and 0/imm32/false
14281 0f 84/jump-if-= break/disp32
14282
14283 68/push 0/imm32
14284 68/push 0/imm32
14285 89/<- %esi 4/r32/esp
14286
14287 (allocate Heap *Function-size %esi)
14288
14289 (lookup *esi *(esi+4))
14290
14291 (clear-stack %ebx)
14292
14293 (populate-mu-function-header %ecx %eax %ebx *(ebp+0xc) *(ebp+0x10))
14294 (populate-mu-function-body *(ebp+8) %eax %ebx *(ebp+0xc) *(ebp+0x10))
14295
14296 8b/-> *esi 0/r32/eax
14297 89/<- *edi 0/r32/eax
14298 8b/-> *(esi+4) 0/r32/eax
14299 89/<- *(edi+4) 0/r32/eax
14300
14301
14302 (lookup *esi *(esi+4))
14303
14304 8d/copy-address *(eax+0x20) 7/r32/edi
14305
14306 81 0/subop/add %esp 8/imm32
14307
14308 e9/jump $parse-mu:line-loop/disp32
14309 }
14310
14311
14312 {
14313 $parse-mu:sig:
14314 (slice-equal? %edx "sig")
14315 3d/compare-eax-and 0/imm32/false
14316 0f 84/jump-if-= break/disp32
14317
14318 57/push-edi
14319 8b/-> *(ebp-4) 7/r32/edi
14320
14321 68/push 0/imm32
14322 68/push 0/imm32
14323 89/<- %esi 4/r32/esp
14324
14325 (allocate Heap *Function-size %esi)
14326
14327 (lookup *esi *(esi+4))
14328
14329 (populate-mu-function-signature %ecx %eax *(ebp+0xc) *(ebp+0x10))
14330
14331 8b/-> *esi 0/r32/eax
14332 89/<- *edi 0/r32/eax
14333 8b/-> *(esi+4) 0/r32/eax
14334 89/<- *(edi+4) 0/r32/eax
14335
14336
14337 (lookup *esi *(esi+4))
14338
14339 8d/copy-address *(eax+0x20) 7/r32/edi
14340
14341 81 0/subop/add %esp 8/imm32
14342
14343 89/<- *(ebp-4) 7/r32/edi
14344
14345 5f/pop-to-edi
14346
14347 e9/jump $parse-mu:line-loop/disp32
14348 }
14349
14350 {
14351 $parse-mu:type:
14352 (slice-equal? %edx "type")
14353 3d/compare-eax-and 0/imm32
14354 0f 84/jump-if-= break/disp32
14355 (next-mu-token %ecx %edx)
14356
14357 (pos-or-insert-slice Type-id %edx)
14358
14359 51/push-ecx
14360
14361 68/push 0/imm32
14362 68/push 0/imm32
14363 89/<- %ecx 4/r32/esp
14364 (find-or-create-typeinfo %eax %ecx)
14365
14366 (lookup *ecx *(ecx+4))
14367
14368
14369 (populate-mu-type *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10))
14370
14371
14372 81 0/subop/add %esp 8/imm32
14373
14374 59/pop-to-ecx
14375 e9/jump $parse-mu:line-loop/disp32
14376 }
14377
14378 e9/jump $parse-mu:error1/disp32
14379 }
14380 $parse-mu:end:
14381
14382 81 0/subop/add %esp 0x20c/imm32
14383 81 0/subop/add %esp 0xc08/imm32
14384 81 0/subop/add %esp 8/imm32
14385
14386 5f/pop-to-edi
14387 5e/pop-to-esi
14388 5b/pop-to-ebx
14389 5a/pop-to-edx
14390 59/pop-to-ecx
14391 58/pop-to-eax
14392
14393 81 0/subop/add %esp 4/imm32
14394
14395 89/<- %esp 5/r32/ebp
14396 5d/pop-to-ebp
14397 c3/return
14398
14399 $parse-mu:error1:
14400
14401 (write-buffered *(ebp+0xc) "unexpected top-level command: ")
14402 (write-slice-buffered *(ebp+0xc) %edx)
14403 (write-buffered *(ebp+0xc) "\n")
14404 (flush *(ebp+0xc))
14405 (stop *(ebp+0x10) 1)
14406
14407
14408 $parse-mu:error2:
14409
14410 (write-int32-hex-buffered *(ebp+0xc) *ebx)
14411 (write-buffered *(ebp+0xc) " vars not reclaimed after fn '")
14412 (write-slice-buffered *(ebp+0xc) *eax)
14413 (write-buffered *(ebp+0xc) "'\n")
14414 (flush *(ebp+0xc))
14415 (stop *(ebp+0x10) 1)
14416
14417
14418
14419
14420
14421
14422
14423
14424
14425
14426
14427
14428
14429
14430
14431
14432 populate-mu-function-header:
14433
14434
14435
14436
14437
14438
14439
14440
14441
14442
14443
14444
14445
14446
14447
14448
14449
14450
14451
14452
14453
14454
14455
14456
14457
14458
14459
14460
14461
14462
14463
14464 55/push-ebp
14465 89/<- %ebp 4/r32/esp
14466
14467 50/push-eax
14468 51/push-ecx
14469 52/push-edx
14470 53/push-ebx
14471 57/push-edi
14472
14473 8b/-> *(ebp+0xc) 7/r32/edi
14474
14475 68/push 0/imm32/end
14476 68/push 0/imm32/start
14477 89/<- %ecx 4/r32/esp
14478
14479 68/push 0/imm32
14480 68/push 0/imm32
14481 89/<- %ebx 4/r32/esp
14482
14483 (next-mu-token *(ebp+8) %ecx)
14484
14485
14486 (slice-empty? %ecx)
14487 3d/compare-eax-and 0/imm32/false
14488 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32
14489
14490 (slice-equal? %ecx "{")
14491 3d/compare-eax-and 0/imm32/false
14492 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32
14493
14494 (slice-equal? %ecx "->")
14495 3d/compare-eax-and 0/imm32/false
14496 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32
14497
14498 (slice-equal? %ecx "}")
14499 3d/compare-eax-and 0/imm32/false
14500 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32
14501
14502 (function-exists? %ecx)
14503 3d/compare-eax-and 0/imm32/false
14504 0f 85/jump-if-!= $populate-mu-function-header:error-duplicate/disp32
14505
14506 (slice-starts-with? %ecx "break")
14507 3d/compare-eax-and 0/imm32/false
14508 0f 85/jump-if-!= $populate-mu-function-header:error-break/disp32
14509 (slice-starts-with? %ecx "loop")
14510 3d/compare-eax-and 0/imm32/false
14511 0f 85/jump-if-!= $populate-mu-function-header:error-loop/disp32
14512 (slice-equal? %ecx "lookup")
14513 3d/compare-eax-and 0/imm32/false
14514 0f 85/jump-if-!= $populate-mu-function-header:error-lookup/disp32
14515
14516 (slice-to-string Heap %ecx %edi)
14517
14518 {
14519 $populate-mu-function-header:check-for-inout:
14520 (next-mu-token *(ebp+8) %ecx)
14521
14522 (slice-empty? %ecx)
14523 3d/compare-eax-and 0/imm32/false
14524 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32
14525
14526 (slice-equal? %ecx "{")
14527 3d/compare-eax-and 0/imm32/false
14528 0f 85/jump-if-!= $populate-mu-function-header:done/disp32
14529
14530 (slice-equal? %ecx "->")
14531 3d/compare-eax-and 0/imm32/false
14532 0f 85/jump-if-!= break/disp32
14533
14534 (slice-equal? %ecx "}")
14535 3d/compare-eax-and 0/imm32/false
14536 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32
14537
14538 (lookup *edi *(edi+4))
14539 (parse-var-with-type %ecx *(ebp+8) %ebx %eax *(ebp+0x14) *(ebp+0x18))
14540
14541
14542 (lookup *ebx *(ebx+4))
14543 81 7/subop/compare *(eax+0x18) 0/imm32
14544 0f 85/jump-if-!= $populate-mu-function-header:error2/disp32
14545
14546
14547 {
14548 (lookup *edi *(edi+4))
14549 (string-equal? %eax "main")
14550 3d/compare-eax-and 0/imm32/false
14551 75/jump-if-!= break/disp8
14552 (lookup *ebx *(ebx+4))
14553 (addr-payload-contains-addr? %eax)
14554 3d/compare-eax-and 0/imm32/false
14555 0f 85/jump-if-!= $populate-mu-function-header:error-nested-addr-inout/disp32
14556 }
14557
14558
14559
14560 8d/copy-address *(edi+8) 0/r32/eax
14561 (append-list Heap *ebx *(ebx+4) *(edi+8) *(edi+0xc) %eax)
14562
14563 (push *(ebp+0x10) *ebx)
14564 (push *(ebp+0x10) *(ebx+4))
14565 (push *(ebp+0x10) 0)
14566
14567 e9/jump loop/disp32
14568 }
14569
14570 {
14571 $populate-mu-function-header:check-for-out:
14572 (next-mu-token *(ebp+8) %ecx)
14573
14574 (slice-empty? %ecx)
14575 3d/compare-eax-and 0/imm32/false
14576 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32
14577
14578 (slice-equal? %ecx "{")
14579 3d/compare-eax-and 0/imm32/false
14580 0f 85/jump-if-!= break/disp32
14581
14582 (slice-equal? %ecx "->")
14583 3d/compare-eax-and 0/imm32/false
14584 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32
14585
14586 (slice-equal? %ecx "}")
14587 3d/compare-eax-and 0/imm32/false
14588 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32
14589
14590 (lookup *edi *(edi+4))
14591 (parse-var-with-type %ecx *(ebp+8) %ebx %eax *(ebp+0x14) *(ebp+0x18))
14592
14593
14594 (lookup *ebx *(ebx+4))
14595 81 7/subop/compare *(eax+0x18) 0/imm32
14596 0f 84/jump-if-= $populate-mu-function-header:error3/disp32
14597
14598 (lookup *eax *(eax+4))
14599 (string-equal? %eax "_")
14600 3d/compare-eax-and 0/imm32/false
14601 0f 84/jump-if-= $populate-mu-function-header:error4/disp32
14602
14603 (lookup *ebx *(ebx+4))
14604 (lookup *(eax+8) *(eax+0xc))
14605 (is-mu-addr-type? %eax)
14606 3d/compare-eax-and 0/imm32/false
14607 0f 85/jump-if-!= $populate-mu-function-header:error-addr-output/disp32
14608
14609 8d/copy-address *(edi+0x10) 0/r32/eax
14610 (append-list Heap *ebx *(ebx+4) *(edi+0x10) *(edi+0x14) %eax)
14611
14612 e9/jump loop/disp32
14613 }
14614 $populate-mu-function-header:done:
14615 (check-no-tokens-left *(ebp+8))
14616 $populate-mu-function-header:end:
14617
14618 81 0/subop/add %esp 0x10/imm32
14619
14620 5f/pop-to-edi
14621 5b/pop-to-ebx
14622 5a/pop-to-edx
14623 59/pop-to-ecx
14624 58/pop-to-eax
14625
14626 89/<- %esp 5/r32/ebp
14627 5d/pop-to-ebp
14628 c3/return
14629
14630 $populate-mu-function-header:error1:
14631
14632 (write-buffered *(ebp+0x14) "function header not in form 'fn <name> [inouts] [-> outputs] {' -- '")
14633 (flush *(ebp+0x14))
14634 (rewind-stream *(ebp+8))
14635 (write-stream-data *(ebp+0x14) *(ebp+8))
14636 (write-buffered *(ebp+0x14) "'\n")
14637 (flush *(ebp+0x14))
14638 (stop *(ebp+0x18) 1)
14639
14640
14641 $populate-mu-function-header:error2:
14642
14643 (write-buffered *(ebp+0x14) "fn ")
14644 50/push-eax
14645 (lookup *edi *(edi+4))
14646 (write-buffered *(ebp+0x14) %eax)
14647 58/pop-to-eax
14648 (write-buffered *(ebp+0x14) ": function inout '")
14649 (lookup *eax *(eax+4))
14650 (write-buffered *(ebp+0x14) %eax)
14651 (write-buffered *(ebp+0x14) "' cannot be in a register")
14652 (flush *(ebp+0x14))
14653 (stop *(ebp+0x18) 1)
14654
14655
14656 $populate-mu-function-header:error3:
14657
14658 (write-buffered *(ebp+0x14) "fn ")
14659 50/push-eax
14660 (lookup *edi *(edi+4))
14661 (write-buffered *(ebp+0x14) %eax)
14662 58/pop-to-eax
14663 (write-buffered *(ebp+0x14) ": function output '")
14664 (lookup *ebx *(ebx+4))
14665 (lookup *eax *(eax+4))
14666 (write-buffered *(ebp+0x14) %eax)
14667 (write-buffered *(ebp+0x14) "' must be in a register, in instruction '")
14668 (rewind-stream *(ebp+8))
14669 (write-stream-data *(ebp+0x14) *(ebp+8))
14670 (write-buffered *(ebp+0x14) "'\n")
14671 (flush *(ebp+0x14))
14672 (stop *(ebp+0x18) 1)
14673
14674
14675 $populate-mu-function-header:error4:
14676
14677 (write-buffered *(ebp+0x14) "fn ")
14678 50/push-eax
14679 (lookup *edi *(edi+4))
14680 (write-buffered *(ebp+0x14) %eax)
14681 58/pop-to-eax
14682 (write-buffered *(ebp+0x14) ": function outputs cannot be named; rename '")
14683 (lookup *ebx *(ebx+4))
14684 (lookup *eax *(eax+4))
14685 (write-buffered *(ebp+0x14) %eax)
14686 (write-buffered *(ebp+0x14) "' in the header to '_'\n")
14687 (flush *(ebp+0x14))
14688 (stop *(ebp+0x18) 1)
14689
14690
14691 $populate-mu-function-header:error-duplicate:
14692 (write-buffered *(ebp+0x14) "fn ")
14693 (write-slice-buffered *(ebp+0x14) %ecx)
14694 (write-buffered *(ebp+0x14) " defined more than once\n")
14695 (flush *(ebp+0x14))
14696 (stop *(ebp+0x18) 1)
14697
14698
14699 $populate-mu-function-header:error-break:
14700 (write-buffered *(ebp+0x14) "Sorry, I've reserved all function names starting with 'break' for now. Please contact mu@akkartik.com.\n")
14701 (flush *(ebp+0x14))
14702 (stop *(ebp+0x18) 1)
14703
14704
14705 $populate-mu-function-header:error-loop:
14706 (write-buffered *(ebp+0x14) "Sorry, I've reserved all function names starting with 'loop' for now. Please contact mu@akkartik.com.\n")
14707 (flush *(ebp+0x14))
14708 (stop *(ebp+0x18) 1)
14709
14710
14711 $populate-mu-function-header:error-lookup:
14712 (write-buffered *(ebp+0x14) "cannot define a function called 'lookup'\n")
14713 (flush *(ebp+0x14))
14714 (stop *(ebp+0x18) 1)
14715
14716
14717 $populate-mu-function-header:error-addr-output:
14718
14719 (write-buffered *(ebp+0x14) "fn ")
14720 50/push-eax
14721 (lookup *edi *(edi+4))
14722 (write-buffered *(ebp+0x14) %eax)
14723 58/pop-to-eax
14724 (write-buffered *(ebp+0x14) ": output cannot have an addr type; that could allow unsafe addresses to escape the function\n")
14725 (flush *(ebp+0x14))
14726 (stop *(ebp+0x18) 1)
14727
14728
14729 $populate-mu-function-header:error-nested-addr-inout:
14730
14731 (write-buffered *(ebp+0x14) "fn ")
14732 (lookup *edi *(edi+4))
14733 (write-buffered *(ebp+0x14) %eax)
14734 (write-buffered *(ebp+0x14) ": inout '")
14735 (lookup *ebx *(ebx+4))
14736 (lookup *eax *(eax+4))
14737 (write-buffered *(ebp+0x14) %eax)
14738 (write-buffered *(ebp+0x14) "' cannot contain 'addr' anywhere in the type except the first word; that could allow unsafe addresses to escape the function\n")
14739 (flush *(ebp+0x14))
14740 (stop *(ebp+0x18) 1)
14741
14742
14743
14744
14745
14746
14747
14748
14749
14750
14751
14752 populate-mu-function-signature:
14753
14754
14755
14756
14757
14758
14759
14760
14761
14762
14763
14764
14765
14766
14767
14768
14769
14770
14771
14772
14773
14774
14775
14776
14777
14778 55/push-ebp
14779 89/<- %ebp 4/r32/esp
14780
14781 50/push-eax
14782 51/push-ecx
14783 52/push-edx
14784 53/push-ebx
14785 57/push-edi
14786
14787 8b/-> *(ebp+0xc) 7/r32/edi
14788
14789 68/push 0/imm32/end
14790 68/push 0/imm32/start
14791 89/<- %ecx 4/r32/esp
14792
14793 68/push 0/imm32
14794 68/push 0/imm32
14795 89/<- %ebx 4/r32/esp
14796
14797 (next-mu-token *(ebp+8) %ecx)
14798
14799
14800 (slice-equal? %ecx "{")
14801 3d/compare-eax-and 0/imm32/false
14802 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32
14803
14804 (slice-equal? %ecx "->")
14805 3d/compare-eax-and 0/imm32/false
14806 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32
14807
14808 (slice-equal? %ecx "}")
14809 3d/compare-eax-and 0/imm32/false
14810 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32
14811
14812 (function-exists? %ecx)
14813 3d/compare-eax-and 0/imm32/false
14814 0f 85/jump-if-!= $populate-mu-function-signature:error-duplicate/disp32
14815
14816 (slice-starts-with? %ecx "break")
14817 3d/compare-eax-and 0/imm32/false
14818 0f 85/jump-if-!= $populate-mu-function-signature:error-break/disp32
14819 (slice-starts-with? %ecx "loop")
14820 3d/compare-eax-and 0/imm32/false
14821 0f 85/jump-if-!= $populate-mu-function-signature:error-loop/disp32
14822
14823 (slice-to-string Heap %ecx %edi)
14824
14825 {
14826 $populate-mu-function-signature:check-for-inout:
14827 (next-mu-token *(ebp+8) %ecx)
14828 (slice-empty? %ecx)
14829 3d/compare-eax-and 0/imm32/false
14830 0f 85/jump-if-!= break/disp32
14831
14832 (slice-equal? %ecx "->")
14833 3d/compare-eax-and 0/imm32/false
14834 0f 85/jump-if-!= break/disp32
14835
14836 (slice-equal? %ecx "{")
14837 3d/compare-eax-and 0/imm32/false
14838 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32
14839
14840 (slice-equal? %ecx "}")
14841 3d/compare-eax-and 0/imm32/false
14842 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32
14843
14844 (lookup *edi *(edi+4))
14845 (parse-var-with-type %ecx *(ebp+8) %ebx %eax *(ebp+0x10) *(ebp+0x14))
14846
14847
14848 (lookup *ebx *(ebx+4))
14849 81 7/subop/compare *(eax+0x18) 0/imm32
14850 0f 85/jump-if-!= $populate-mu-function-signature:error2/disp32
14851
14852
14853 {
14854 (lookup *edi *(edi+4))
14855 (string-equal? %eax "main")
14856 3d/compare-eax-and 0/imm32/false
14857 75/jump-if-!= break/disp8
14858 (lookup *ebx *(ebx+4))
14859 (addr-payload-contains-addr? %eax)
14860 3d/compare-eax-and 0/imm32/false
14861 0f 85/jump-if-!= $populate-mu-function-signature:error-nested-addr-inout/disp32
14862 }
14863
14864
14865 (lookup *ebx *(ebx+4))
14866 81 7/subop/compare *(eax+0x18) 0/imm32
14867 0f 85/jump-if-!= $populate-mu-function-signature:error2/disp32
14868
14869
14870
14871 8d/copy-address *(edi+8) 0/r32/eax
14872 (append-list Heap *ebx *(ebx+4) *(edi+8) *(edi+0xc) %eax)
14873
14874 e9/jump loop/disp32
14875 }
14876
14877 {
14878 $populate-mu-function-signature:check-for-out:
14879 (next-mu-token *(ebp+8) %ecx)
14880 (slice-empty? %ecx)
14881 3d/compare-eax-and 0/imm32/false
14882 0f 85/jump-if-!= break/disp32
14883
14884 (slice-equal? %ecx "{")
14885 3d/compare-eax-and 0/imm32/false
14886 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32
14887
14888 (slice-equal? %ecx "->")
14889 3d/compare-eax-and 0/imm32/false
14890 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32
14891
14892 (slice-equal? %ecx "}")
14893 3d/compare-eax-and 0/imm32/false
14894 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32
14895
14896 (lookup *edi *(edi+4))
14897 (parse-var-with-type %ecx *(ebp+8) %ebx %eax *(ebp+0x10) *(ebp+0x14))
14898
14899
14900 (lookup *ebx *(ebx+4))
14901 81 7/subop/compare *(eax+0x18) 0/imm32
14902 0f 84/jump-if-= $populate-mu-function-signature:error3/disp32
14903
14904 (lookup *eax *(eax+4))
14905 (string-equal? %eax "_")
14906 3d/compare-eax-and 0/imm32/false
14907 0f 84/jump-if-= $populate-mu-function-signature:error4/disp32
14908
14909
14910 {
14911 (lookup *edi *(edi+4))
14912 (string-equal? %eax "lookup")
14913 3d/compare-eax-and 0/imm32/false
14914 75/jump-if-!= break/disp8
14915 (lookup *ebx *(ebx+4))
14916 (lookup *(eax+8) *(eax+0xc))
14917 (is-mu-addr-type? %eax)
14918 3d/compare-eax-and 0/imm32/false
14919 0f 85/jump-if-!= $populate-mu-function-signature:error-addr-output/disp32
14920 }
14921
14922 8d/copy-address *(edi+0x10) 0/r32/eax
14923 (append-list Heap *ebx *(ebx+4) *(edi+0x10) *(edi+0x14) %eax)
14924
14925 e9/jump loop/disp32
14926 }
14927 $populate-mu-function-signature:done:
14928 (check-no-tokens-left *(ebp+8))
14929 $populate-mu-function-signature:end:
14930
14931 81 0/subop/add %esp 0x10/imm32
14932
14933 5f/pop-to-edi
14934 5b/pop-to-ebx
14935 5a/pop-to-edx
14936 59/pop-to-ecx
14937 58/pop-to-eax
14938
14939 89/<- %esp 5/r32/ebp
14940 5d/pop-to-ebp
14941 c3/return
14942
14943 $populate-mu-function-signature:error1:
14944
14945 (write-buffered *(ebp+0x10) "function signature not in form 'fn <name> [inouts] [-> outputs] {' -- '")
14946 (flush *(ebp+0x10))
14947 (rewind-stream *(ebp+8))
14948 (write-stream-data *(ebp+0x10) *(ebp+8))
14949 (write-buffered *(ebp+0x10) "'\n")
14950 (flush *(ebp+0x10))
14951 (stop *(ebp+0x14) 1)
14952
14953
14954 $populate-mu-function-signature:error2:
14955
14956 (write-buffered *(ebp+0x10) "fn ")
14957 50/push-eax
14958 (lookup *edi *(edi+4))
14959 (write-buffered *(ebp+0x10) %eax)
14960 58/pop-to-eax
14961 (write-buffered *(ebp+0x10) ": function inout '")
14962 (lookup *eax *(eax+4))
14963 (write-buffered *(ebp+0x10) %eax)
14964 (write-buffered *(ebp+0x10) "' cannot be in a register")
14965 (flush *(ebp+0x10))
14966 (stop *(ebp+0x14) 1)
14967
14968
14969 $populate-mu-function-signature:error3:
14970
14971 (write-buffered *(ebp+0x10) "fn ")
14972 50/push-eax
14973 (lookup *edi *(edi+4))
14974 (write-buffered *(ebp+0x10) %eax)
14975 58/pop-to-eax
14976 (write-buffered *(ebp+0x10) ": function output '")
14977 (lookup *ebx *(ebx+4))
14978 (lookup *eax *(eax+4))
14979 (write-buffered *(ebp+0x10) %eax)
14980 (write-buffered *(ebp+0x10) "' must be in a register, in instruction '")
14981 (rewind-stream *(ebp+8))
14982 (write-stream-data *(ebp+0x10) *(ebp+8))
14983 (write-buffered *(ebp+0x10) "'\n")
14984 (flush *(ebp+0x10))
14985 (stop *(ebp+0x14) 1)
14986
14987
14988 $populate-mu-function-signature:error4:
14989
14990 (write-buffered *(ebp+0x10) "fn ")
14991 50/push-eax
14992 (lookup *edi *(edi+4))
14993 (write-buffered *(ebp+0x10) %eax)
14994 58/pop-to-eax
14995 (write-buffered *(ebp+0x10) ": function outputs cannot be named; rename '")
14996 (lookup *ebx *(ebx+4))
14997 (lookup *eax *(eax+4))
14998 (write-buffered *(ebp+0x10) %eax)
14999 (write-buffered *(ebp+0x10) "' in the header to '_'\n")
15000 (flush *(ebp+0x10))
15001 (stop *(ebp+0x14) 1)
15002
15003
15004 $populate-mu-function-signature:error-duplicate:
15005 (write-buffered *(ebp+0x10) "fn ")
15006 (write-slice-buffered *(ebp+0x10) %ecx)
15007 (write-buffered *(ebp+0x10) " defined more than once\n")
15008 (flush *(ebp+0x10))
15009 (stop *(ebp+0x14) 1)
15010
15011
15012 $populate-mu-function-signature:error-break:
15013 (write-buffered *(ebp+0x10) "Sorry, I've reserved all function names starting with 'break' for now. Please contact mu@akkartik.com.\n")
15014 (flush *(ebp+0x10))
15015 (stop *(ebp+0x14) 1)
15016
15017
15018 $populate-mu-function-signature:error-loop:
15019 (write-buffered *(ebp+0x10) "Sorry, I've reserved all function names starting with 'loop' for now. Please contact mu@akkartik.com.\n")
15020 (flush *(ebp+0x10))
15021 (stop *(ebp+0x14) 1)
15022
15023
15024 $populate-mu-function-signature:error-addr-output:
15025
15026 (write-buffered *(ebp+0x10) "fn ")
15027 50/push-eax
15028 (lookup *edi *(edi+4))
15029 (write-buffered *(ebp+0x10) %eax)
15030 58/pop-to-eax
15031 (write-buffered *(ebp+0x10) ": output cannot have an addr type; that could allow unsafe addresses to escape the function\n")
15032 (flush *(ebp+0x10))
15033 (stop *(ebp+0x14) 1)
15034
15035
15036 $populate-mu-function-signature:error-nested-addr-inout:
15037
15038 (write-buffered *(ebp+0x10) "fn ")
15039 (lookup *edi *(edi+4))
15040 (write-buffered *(ebp+0x10) %eax)
15041 (write-buffered *(ebp+0x10) ": inout '")
15042 (lookup *ebx *(ebx+4))
15043 (lookup *eax *(eax+4))
15044 (write-buffered *(ebp+0x10) %eax)
15045 (write-buffered *(ebp+0x10) "' cannot contain 'addr' anywhere in the type except the first word; that could allow unsafe addresses to escape the function\n")
15046 (flush *(ebp+0x10))
15047 (stop *(ebp+0x14) 1)
15048
15049
15050 addr-payload-contains-addr?:
15051
15052 55/push-ebp
15053 89/<- %ebp 4/r32/esp
15054
15055 8b/-> *(ebp+8) 0/r32/eax
15056 (lookup *(eax+8) *(eax+0xc))
15057
15058 (lookup *(eax+0xc) *(eax+0x10))
15059 (type-tree-contains? %eax 2)
15060
15061 $addr-payload-contains-addr?:end:
15062
15063 89/<- %esp 5/r32/ebp
15064 5d/pop-to-ebp
15065 c3/return
15066
15067 type-tree-contains?:
15068
15069 55/push-ebp
15070 89/<- %ebp 4/r32/esp
15071
15072 51/push-ecx
15073
15074 8b/-> *(ebp+8) 0/r32/eax
15075 3d/compare-eax-and 0/imm32
15076 0f 84/jump-if-= $type-tree-contains?:end/disp32
15077
15078 81 7/subop/compare *eax 0/imm32/false
15079 {
15080 74/jump-if-= break/disp8
15081 8b/-> *(ebp+0xc) 1/r32/ecx
15082 39/compare *(eax+4) 1/r32/ecx
15083 0f 94/set-if-= %al
15084 81 4/subop/and %eax 0xff/imm32
15085 eb/jump $type-tree-contains?:end/disp8
15086 }
15087
15088 (lookup *(eax+4) *(eax+8))
15089 (type-tree-contains? %eax *(ebp+0xc))
15090 3d/compare-eax-and 0/imm32/false
15091 75/jump-if-!= $type-tree-contains?:end/disp8
15092
15093 8b/-> *(ebp+8) 0/r32/eax
15094 (lookup *(eax+0xc) *(eax+0x10))
15095 (type-tree-contains? %eax *(ebp+0xc))
15096 $type-tree-contains?:end:
15097
15098 59/pop-to-ecx
15099
15100 89/<- %esp 5/r32/ebp
15101 5d/pop-to-ebp
15102 c3/return
15103
15104 function-exists?:
15105
15106 55/push-ebp
15107 89/<- %ebp 4/r32/esp
15108
15109 51/push-ecx
15110
15111 (lookup *_Program-functions *_Program-functions->payload)
15112 89/<- %ecx 0/r32/eax
15113 {
15114
15115 81 7/subop/compare %ecx 0/imm32
15116 74/jump-if-= break/disp8
15117
15118 {
15119 (lookup *ecx *(ecx+4))
15120 (slice-equal? *(ebp+8) %eax)
15121 3d/compare-eax-and 0/imm32/false
15122 74/jump-if-= break/disp8
15123 b8/copy-to-eax 1/imm32/true
15124 e9/jump $function-exists?:end/disp32
15125 }
15126
15127 (lookup *(ecx+0x20) *(ecx+0x24))
15128 89/<- %ecx 0/r32/eax
15129
15130 eb/jump loop/disp8
15131 }
15132
15133 (lookup *_Program-signatures *_Program-signatures->payload)
15134 89/<- %ecx 0/r32/eax
15135 {
15136
15137 81 7/subop/compare %ecx 0/imm32
15138 74/jump-if-= break/disp8
15139
15140 {
15141 (lookup *ecx *(ecx+4))
15142 (slice-equal? *(ebp+8) %eax)
15143 3d/compare-eax-and 0/imm32/false
15144 74/jump-if-= break/disp8
15145 b8/copy-to-eax 1/imm32/true
15146 eb/jump $function-exists?:end/disp8
15147 }
15148
15149 (lookup *(ecx+0x20) *(ecx+0x24))
15150 89/<- %ecx 0/r32/eax
15151
15152 eb/jump loop/disp8
15153 }
15154
15155 b8/copy-to-eax 0/imm32/false
15156 $function-exists?:end:
15157
15158 59/pop-to-ecx
15159
15160 89/<- %esp 5/r32/ebp
15161 5d/pop-to-ebp
15162 c3/return
15163
15164 test-function-header-with-arg:
15165
15166 55/push-ebp
15167 89/<- %ebp 4/r32/esp
15168
15169 8b/-> *Primitive-type-ids 0/r32/eax
15170 89/<- *Type-id 0/r32/eax
15171 c7 0/subop/copy *_Program-functions 0/imm32
15172 c7 0/subop/copy *_Program-functions->payload 0/imm32
15173 c7 0/subop/copy *_Program-types 0/imm32
15174 c7 0/subop/copy *_Program-types->payload 0/imm32
15175 c7 0/subop/copy *_Program-signatures 0/imm32
15176 c7 0/subop/copy *_Program-signatures->payload 0/imm32
15177 (clear-stream _test-input-stream)
15178 (write _test-input-stream "foo n: int {\n")
15179
15180 2b/subtract *Function-size 4/r32/esp
15181 89/<- %ecx 4/r32/esp
15182 (zero-out %ecx *Function-size)
15183
15184 81 5/subop/subtract %esp 0xc0/imm32
15185 68/push 0xc0/imm32/size
15186 68/push 0/imm32/top
15187 89/<- %ebx 4/r32/esp
15188
15189 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0)
15190
15191 (lookup *ecx *(ecx+4))
15192 (check-strings-equal %eax "foo" "F - test-function-header-with-arg/name")
15193
15194 (lookup *(ecx+8) *(ecx+0xc))
15195 (lookup *eax *(eax+4))
15196 89/<- %edx 0/r32/eax
15197
15198 (lookup *edx *(edx+4))
15199 (check-strings-equal %eax "n" "F - test-function-header-with-arg/inout:0")
15200
15201 (lookup *(edx+8) *(edx+0xc))
15202 (check-ints-equal *eax 1 "F - test-function-header-with-arg/inout:0/type:0")
15203 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-arg/inout:0/type:1")
15204 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-arg/inout:0/type:2")
15205
15206 89/<- %esp 5/r32/ebp
15207 5d/pop-to-ebp
15208 c3/return
15209
15210 test-function-header-with-multiple-args:
15211
15212 55/push-ebp
15213 89/<- %ebp 4/r32/esp
15214
15215 8b/-> *Primitive-type-ids 0/r32/eax
15216 89/<- *Type-id 0/r32/eax
15217 c7 0/subop/copy *_Program-functions 0/imm32
15218 c7 0/subop/copy *_Program-functions->payload 0/imm32
15219 c7 0/subop/copy *_Program-types 0/imm32
15220 c7 0/subop/copy *_Program-types->payload 0/imm32
15221 c7 0/subop/copy *_Program-signatures 0/imm32
15222 c7 0/subop/copy *_Program-signatures->payload 0/imm32
15223 (clear-stream _test-input-stream)
15224 (write _test-input-stream "foo a: int, b: int c: int {\n")
15225
15226 2b/subtract *Function-size 4/r32/esp
15227 89/<- %ecx 4/r32/esp
15228 (zero-out %ecx *Function-size)
15229
15230 81 5/subop/subtract %esp 0xc0/imm32
15231 68/push 0xc0/imm32/size
15232 68/push 0/imm32/top
15233 89/<- %ebx 4/r32/esp
15234
15235 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0)
15236
15237 (lookup *ecx *(ecx+4))
15238 (check-strings-equal %eax "foo" "F - test-function-header-with-multiple-args/name")
15239
15240 (lookup *(ecx+8) *(ecx+0xc))
15241 89/<- %edx 0/r32/eax
15242 $test-function-header-with-multiple-args:inout0:
15243
15244 (lookup *edx *(edx+4))
15245 89/<- %ebx 0/r32/eax
15246
15247 (lookup *ebx *(ebx+4))
15248 (check-strings-equal %eax "a" "F - test-function-header-with-multiple-args/inout:0")
15249
15250 (lookup *(ebx+8) *(ebx+0xc))
15251 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:0/type:0")
15252 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:0/type:1")
15253 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:0/type:2")
15254 $test-function-header-with-multiple-args:inout1:
15255
15256 (lookup *(edx+8) *(edx+0xc))
15257 89/<- %edx 0/r32/eax
15258
15259 (lookup *edx *(edx+4))
15260 89/<- %ebx 0/r32/eax
15261
15262 (lookup *ebx *(ebx+4))
15263 (check-strings-equal %eax "b" "F - test-function-header-with-multiple-args/inout:1")
15264
15265 (lookup *(ebx+8) *(ebx+0xc))
15266 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:1/type:0")
15267 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:1/type:1")
15268 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:1/type:2")
15269 $test-function-header-with-multiple-args:inout2:
15270
15271 (lookup *(edx+8) *(edx+0xc))
15272 89/<- %edx 0/r32/eax
15273
15274 (lookup *edx *(edx+4))
15275 89/<- %ebx 0/r32/eax
15276
15277 (lookup *ebx *(ebx+4))
15278 (check-strings-equal %eax "c" "F - test-function-header-with-multiple-args/inout:2")
15279
15280 (lookup *(ebx+8) *(ebx+0xc))
15281 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:2/type:0")
15282 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:2/type:1")
15283 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:2/type:2")
15284
15285 89/<- %esp 5/r32/ebp
15286 5d/pop-to-ebp
15287 c3/return
15288
15289 test-function-header-with-multiple-args-and-outputs:
15290
15291 55/push-ebp
15292 89/<- %ebp 4/r32/esp
15293
15294 8b/-> *Primitive-type-ids 0/r32/eax
15295 89/<- *Type-id 0/r32/eax
15296 c7 0/subop/copy *_Program-functions 0/imm32
15297 c7 0/subop/copy *_Program-functions->payload 0/imm32
15298 c7 0/subop/copy *_Program-types 0/imm32
15299 c7 0/subop/copy *_Program-types->payload 0/imm32
15300 c7 0/subop/copy *_Program-signatures 0/imm32
15301 c7 0/subop/copy *_Program-signatures->payload 0/imm32
15302 (clear-stream _test-input-stream)
15303 (write _test-input-stream "foo a: int, b: int, c: int -> _/ecx: int _/edx: int {\n")
15304
15305 2b/subtract *Function-size 4/r32/esp
15306 89/<- %ecx 4/r32/esp
15307 (zero-out %ecx *Function-size)
15308
15309 81 5/subop/subtract %esp 0xc0/imm32
15310 68/push 0xc0/imm32/size
15311 68/push 0/imm32/top
15312 89/<- %ebx 4/r32/esp
15313
15314 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0)
15315
15316 (lookup *ecx *(ecx+4))
15317 (check-strings-equal %eax "foo" "F - test-function-header-with-multiple-args-and-outputs/name")
15318
15319 (lookup *(ecx+8) *(ecx+0xc))
15320 89/<- %edx 0/r32/eax
15321 $test-function-header-with-multiple-args-and-outputs:inout0:
15322
15323 (lookup *edx *(edx+4))
15324 89/<- %ebx 0/r32/eax
15325
15326 (lookup *ebx *(ebx+4))
15327 (check-strings-equal %eax "a" "F - test-function-header-with-multiple-args-and-outputs/inout:0")
15328
15329 (lookup *(ebx+8) *(ebx+0xc))
15330 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:0")
15331 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:1")
15332 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:2")
15333 $test-function-header-with-multiple-args-and-outputs:inout1:
15334
15335 (lookup *(edx+8) *(edx+0xc))
15336 89/<- %edx 0/r32/eax
15337
15338 (lookup *edx *(edx+4))
15339 89/<- %ebx 0/r32/eax
15340
15341 (lookup *ebx *(ebx+4))
15342 (check-strings-equal %eax "b" "F - test-function-header-with-multiple-args-and-outputs/inout:1")
15343
15344 (lookup *(ebx+8) *(ebx+0xc))
15345 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:0")
15346 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:1")
15347 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:2")
15348 $test-function-header-with-multiple-args-and-outputs:inout2:
15349
15350 (lookup *(edx+8) *(edx+0xc))
15351 89/<- %edx 0/r32/eax
15352
15353 (lookup *edx *(edx+4))
15354 89/<- %ebx 0/r32/eax
15355
15356 (lookup *ebx *(ebx+4))
15357 (check-strings-equal %eax "c" "F - test-function-header-with-multiple-args-and-outputs/inout:2")
15358
15359 (lookup *(ebx+8) *(ebx+0xc))
15360 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:0")
15361 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:1")
15362 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:2")
15363 $test-function-header-with-multiple-args-and-outputs:out0:
15364
15365 (lookup *(ecx+0x10) *(ecx+0x14))
15366 89/<- %edx 0/r32/eax
15367
15368 (lookup *edx *(edx+4))
15369 89/<- %ebx 0/r32/eax
15370
15371 (lookup *ebx *(ebx+4))
15372 (check-strings-equal %eax "_" "F - test-function-header-with-multiple-args-and-outputs/output:0")
15373
15374 (lookup *(ebx+0x18) *(ebx+0x1c))
15375 (check-strings-equal %eax "ecx" "F - test-function-header-with-multiple-args-and-outputs/output:0/register")
15376
15377 (lookup *(ebx+8) *(ebx+0xc))
15378 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:0")
15379 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:1")
15380 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:2")
15381 $test-function-header-with-multiple-args-and-outputs:out1:
15382
15383 (lookup *(edx+8) *(edx+0xc))
15384 89/<- %edx 0/r32/eax
15385
15386 (lookup *edx *(edx+4))
15387 89/<- %ebx 0/r32/eax
15388
15389 (lookup *ebx *(ebx+4))
15390 (check-strings-equal %eax "_" "F - test-function-header-with-multiple-args-and-outputs/output:1")
15391
15392 (lookup *(ebx+0x18) *(ebx+0x1c))
15393 (check-strings-equal %eax "edx" "F - test-function-header-with-multiple-args-and-outputs/output:1/register")
15394
15395 (lookup *(ebx+8) *(ebx+0xc))
15396 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:0")
15397 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:1")
15398 (check-ints-equal *(eax+0c) 0 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:2")
15399
15400 89/<- %esp 5/r32/ebp
15401 5d/pop-to-ebp
15402 c3/return
15403
15404
15405
15406
15407
15408
15409
15410
15411 parse-var-with-type:
15412
15413
15414
15415
15416
15417
15418
15419
15420
15421
15422
15423
15424
15425
15426
15427
15428 55/push-ebp
15429 89/<- %ebp 4/r32/esp
15430
15431 50/push-eax
15432 51/push-ecx
15433 52/push-edx
15434 53/push-ebx
15435 56/push-esi
15436 57/push-edi
15437
15438 8b/-> *(ebp+8) 6/r32/esi
15439
15440 8b/-> *(esi+4) 1/r32/ecx
15441 49/decrement-ecx
15442 8a/copy-byte *ecx 1/r32/CL
15443 81 4/subop/and %ecx 0xff/imm32
15444 81 7/subop/compare %ecx 0x3a/imm32/colon
15445 0f 85/jump-if-!= $parse-var-with-type:abort/disp32
15446
15447 ff 1/subop/decrement *(esi+4)
15448
15449 68/push 0/imm32/end
15450 68/push 0/imm32/start
15451 89/<- %ecx 4/r32/esp
15452 $parse-var-with-type:parse-name:
15453 (next-token-from-slice *esi *(esi+4) 0x2f %ecx)
15454 $parse-var-with-type:create-var:
15455
15456 (new-var-from-slice Heap %ecx *(ebp+0x10))
15457
15458 $parse-var-with-type:save-register:
15459
15460 8b/-> *(ebp+0x10) 7/r32/edi
15461 (lookup *edi *(edi+4))
15462 89/<- %edi 0/r32/eax
15463
15464 (next-token-from-slice *(ecx+4) *(esi+4) 0x2f %ecx)
15465
15466 {
15467 $parse-var-with-type:write-register:
15468 (slice-empty? %ecx)
15469 3d/compare-eax-and 0/imm32/false
15470 75/jump-if-!= break/disp8
15471
15472 8d/copy-address *(edi+0x18) 0/r32/eax
15473 (slice-to-string Heap %ecx %eax)
15474 }
15475 $parse-var-with-type:save-type:
15476 8d/copy-address *(edi+8) 0/r32/eax
15477 (parse-type Heap *(ebp+0xc) %eax *(ebp+0x18) *(ebp+0x1c))
15478 $parse-var-with-type:check-register:
15479 (lookup *(edi+0x18) *(edi+0x1c))
15480 3d/compare-eax-and 0/imm32
15481 74/jump-if-= $parse-var-with-type:end/disp8
15482 (is-float-register? %eax)
15483 {
15484 3d/compare-eax-and 0/imm32/false
15485 74/jump-if-= break/disp8
15486
15487 (lookup *(edi+8) *(edi+0xc))
15488 (is-simple-mu-type? %eax 0xf)
15489 3d/compare-eax-and 0/imm32/false
15490 0f 84/jump-if-= $parse-var-with-type:error-non-float-in-floating-point-register/disp32
15491 eb/jump $parse-var-with-type:end/disp8
15492 }
15493
15494 (lookup *(edi+8) *(edi+0xc))
15495 (is-simple-mu-type? %eax 0xf)
15496 3d/compare-eax-and 0/imm32/false
15497 0f 85/jump-if-!= $parse-var-with-type:error-float-in-integer-register/disp32
15498 $parse-var-with-type:end:
15499
15500 81 0/subop/add %esp 8/imm32
15501
15502 5f/pop-to-edi
15503 5e/pop-to-esi
15504 5b/pop-to-ebx
15505 5a/pop-to-edx
15506 59/pop-to-ecx
15507 58/pop-to-eax
15508
15509 89/<- %esp 5/r32/ebp
15510 5d/pop-to-ebp
15511 c3/return
15512
15513 $parse-var-with-type:abort:
15514
15515 (write-buffered *(ebp+0x18) "fn ")
15516 (write-buffered *(ebp+0x18) *(ebp+0x14))
15517 (write-buffered *(ebp+0x18) ": var should have form 'name: type' in '")
15518 (flush *(ebp+0x18))
15519 (rewind-stream *(ebp+0xc))
15520 (write-stream-data *(ebp+0x18) *(ebp+0xc))
15521 (write-buffered *(ebp+0x18) "'\n")
15522 (flush *(ebp+0x18))
15523 (stop *(ebp+0x1c) 1)
15524
15525
15526 $parse-var-with-type:error-float-in-integer-register:
15527
15528 (write-buffered *(ebp+0x18) "fn ")
15529 (write-buffered *(ebp+0x18) *(ebp+0x14))
15530 (write-buffered *(ebp+0x18) ": float var '")
15531 (lookup *edi *(edi+4))
15532 (write-buffered *(ebp+0x18) %eax)
15533 (write-buffered *(ebp+0x18) "' should be in a floating-point register\n")
15534 (flush *(ebp+0x18))
15535 (stop *(ebp+0x1c) 1)
15536
15537
15538 $parse-var-with-type:error-non-float-in-floating-point-register:
15539
15540 (write-buffered *(ebp+0x18) "fn ")
15541 (write-buffered *(ebp+0x18) *(ebp+0x14))
15542 (write-buffered *(ebp+0x18) ": non-float var '")
15543 (lookup *edi *(edi+4))
15544 (write-buffered *(ebp+0x18) %eax)
15545 (write-buffered *(ebp+0x18) "' should be in an integer register\n")
15546 (flush *(ebp+0x18))
15547 (stop *(ebp+0x1c) 1)
15548
15549
15550 is-float-register?:
15551
15552 55/push-ebp
15553 89/<- %ebp 4/r32/esp
15554
15555 (get Mu-registers-unique *(ebp+8) 0xc "Mu-registers-unique")
15556 81 7/subop/compare *eax 8/imm32/start-of-floating-point-registers
15557 0f 9d/set-if->= %al
15558 81 4/subop/and %eax 0xff/imm32
15559 $is-float-register?:end:
15560
15561 89/<- %esp 5/r32/ebp
15562 5d/pop-to-ebp
15563 c3/return
15564
15565 parse-type:
15566
15567
15568
15569
15570
15571
15572
15573
15574
15575
15576
15577
15578
15579
15580
15581
15582
15583
15584
15585
15586
15587
15588 55/push-ebp
15589 89/<- %ebp 4/r32/esp
15590
15591 50/push-eax
15592 51/push-ecx
15593 52/push-edx
15594
15595 (zero-out *(ebp+0x10) *Handle-size)
15596
15597 68/push 0/imm32
15598 68/push 0/imm32
15599 89/<- %ecx 4/r32/esp
15600
15601 (next-mu-token *(ebp+0xc) %ecx)
15602
15603
15604
15605
15606
15607 (slice-equal? %ecx "")
15608 3d/compare-eax-and 0/imm32/false
15609 0f 85/jump-if-!= $parse-type:abort/disp32
15610
15611 (slice-equal? %ecx "{")
15612 3d/compare-eax-and 0/imm32/false
15613 0f 85/jump-if-!= $parse-type:abort/disp32
15614
15615 (slice-equal? %ecx "}")
15616 3d/compare-eax-and 0/imm32/false
15617 0f 85/jump-if-!= $parse-type:abort/disp32
15618
15619 (slice-equal? %ecx "->")
15620 3d/compare-eax-and 0/imm32/false
15621 0f 85/jump-if-!= $parse-type:abort/disp32
15622
15623 (slice-equal? %ecx ")")
15624 3d/compare-eax-and 0/imm32/false
15625 0f 85/jump-if-!= $parse-type:end/disp32
15626
15627 (allocate *(ebp+8) *Type-tree-size *(ebp+0x10))
15628
15629 8b/-> *(ebp+0x10) 2/r32/edx
15630 (lookup *edx *(edx+4))
15631 89/<- %edx 0/r32/eax
15632 {
15633
15634 (slice-equal? %ecx "(")
15635 3d/compare-eax-and 0/imm32/false
15636 0f 85/jump-if-!= break/disp32
15637
15638 {
15639 $parse-type:check-for-int:
15640
15641 8b/-> *ecx 0/r32/eax
15642 8a/copy-byte *eax 0/r32/AL
15643 81 4/subop/and %eax 0xff/imm32
15644
15645 (is-decimal-digit? %eax)
15646 3d/compare-eax-and 0/imm32/false
15647 74/jump-if-= break/disp8
15648
15649 (is-hex-int? %ecx)
15650 3d/compare-eax-and 0/imm32/false
15651 74/jump-if-= break/disp8
15652 $parse-type:int:
15653 (check-mu-hex-int %ecx *(ebp+0x14) *(ebp+0x18))
15654 (parse-hex-int-from-slice %ecx)
15655 c7 0/subop/copy *(edx+4) 9/imm32/type-id-array-capacity
15656 89/<- *(edx+8) 0/r32/eax
15657 e9/jump $parse-type:end/disp32
15658 }
15659 $parse-type:atom:
15660
15661 c7 0/subop/copy *edx 1/imm32/true
15662 {
15663 $parse-type:check-for-type-parameter:
15664
15665 8b/-> *ecx 0/r32/eax
15666 8a/copy-byte *eax 0/r32/AL
15667 81 4/subop/and %eax 0xff/imm32
15668
15669 3d/compare-eax-and 0x5f/imm32/_
15670 75/jump-if-!= break/disp8
15671 $parse-type:type-parameter:
15672
15673 c7 0/subop/copy *(edx+4) 0xa/imm32/type-parameter
15674
15675 8d/copy-address *(edx+8) 0/r32/eax
15676 (slice-to-string *(ebp+8) %ecx %eax)
15677 e9/jump $parse-type:end/disp32
15678 }
15679 $parse-type:non-type-parameter:
15680
15681 (pos-or-insert-slice Type-id %ecx)
15682 89/<- *(edx+4) 0/r32/eax
15683 e9/jump $parse-type:end/disp32
15684 }
15685 $parse-type:non-atom:
15686
15687
15688 8d/copy-address *(edx+4) 0/r32/eax
15689 (parse-type *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18))
15690
15691 8d/copy-address *(edx+0xc) 0/r32/eax
15692 (parse-type-tree *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18))
15693 $parse-type:end:
15694
15695 81 0/subop/add %esp 8/imm32
15696
15697 5a/pop-to-edx
15698 59/pop-to-ecx
15699 58/pop-to-eax
15700
15701 89/<- %esp 5/r32/ebp
15702 5d/pop-to-ebp
15703 c3/return
15704
15705 $parse-type:abort:
15706
15707 (write-buffered *(ebp+0x14) "unexpected token when parsing type: '")
15708 (write-slice-buffered *(ebp+0x14) %ecx)
15709 (write-buffered *(ebp+0x14) "'\n")
15710 (flush *(ebp+0x14))
15711 (stop *(ebp+0x18) 1)
15712
15713
15714 parse-type-tree:
15715
15716
15717
15718
15719
15720
15721
15722
15723
15724 55/push-ebp
15725 89/<- %ebp 4/r32/esp
15726
15727 50/push-eax
15728 51/push-ecx
15729 52/push-edx
15730
15731 (zero-out *(ebp+0x10) *Handle-size)
15732
15733 68/push 0/imm32
15734 68/push 0/imm32
15735 89/<- %ecx 4/r32/esp
15736
15737 (parse-type *(ebp+8) *(ebp+0xc) %ecx *(ebp+0x14) *(ebp+0x18))
15738
15739 81 7/subop/compare *ecx 0/imm32
15740 74/jump-if-= $parse-type-tree:end/disp8
15741
15742 (allocate *(ebp+8) *Type-tree-size *(ebp+0x10))
15743
15744 8b/-> *(ebp+0x10) 2/r32/edx
15745 (lookup *edx *(edx+4))
15746 89/<- %edx 0/r32/eax
15747
15748 8b/-> *ecx 0/r32/eax
15749 89/<- *(edx+4) 0/r32/eax
15750 8b/-> *(ecx+4) 0/r32/eax
15751 89/<- *(edx+8) 0/r32/eax
15752
15753 8d/copy-address *(edx+0xc) 0/r32/eax
15754 (parse-type-tree *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18))
15755 $parse-type-tree:end:
15756
15757 81 0/subop/add %esp 8/imm32
15758
15759 5a/pop-to-edx
15760 59/pop-to-ecx
15761 58/pop-to-eax
15762
15763 89/<- %esp 5/r32/ebp
15764 5d/pop-to-ebp
15765 c3/return
15766
15767 next-mu-token:
15768
15769
15770
15771
15772
15773
15774
15775
15776
15777
15778
15779
15780
15781
15782
15783
15784
15785
15786
15787
15788
15789
15790
15791
15792
15793
15794
15795
15796
15797
15798
15799
15800
15801
15802
15803
15804
15805
15806
15807
15808
15809
15810
15811
15812 55/push-ebp
15813 89/<- %ebp 4/r32/esp
15814
15815 50/push-eax
15816 51/push-ecx
15817 56/push-esi
15818 57/push-edi
15819
15820 8b/-> *(ebp+8) 6/r32/esi
15821
15822 8b/-> *(ebp+0xc) 7/r32/edi
15823 $next-mu-token:start:
15824 (skip-chars-matching-whitespace %esi)
15825 $next-mu-token:check0:
15826
15827
15828 8b/-> *(esi+4) 1/r32/ecx
15829
15830 3b/compare<- *esi 1/r32/ecx
15831 c7 0/subop/copy *edi 0/imm32
15832 c7 0/subop/copy *(edi+4) 0/imm32
15833 0f 8d/jump-if->= $next-mu-token:end/disp32
15834
15835 8d/copy-address *(esi+ecx+0xc) 0/r32/eax
15836 89/<- *edi 0/r32/eax
15837
15838 31/xor-with %eax 0/r32/eax
15839 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL
15840 {
15841 $next-mu-token:check-for-comma:
15842
15843 3d/compare-eax-and 0x2c/imm32/comma
15844 75/jump-if-!= break/disp8
15845
15846 ff 0/subop/increment *(esi+4)
15847
15848 e9/jump $next-mu-token:start/disp32
15849 }
15850 {
15851 $next-mu-token:check-for-comment:
15852
15853 3d/compare-eax-and 0x23/imm32/pound
15854 75/jump-if-!= break/disp8
15855
15856 e9/jump $next-mu-token:done/disp32
15857 }
15858 {
15859 $next-mu-token:check-for-string-literal:
15860
15861 3d/compare-eax-and 0x22/imm32/dquote
15862 75/jump-if-!= break/disp8
15863 (skip-string %esi)
15864
15865 e9/jump $next-mu-token:done/disp32
15866 }
15867 {
15868 $next-mu-token:check-for-open-paren:
15869
15870 3d/compare-eax-and 0x28/imm32/open-paren
15871 75/jump-if-!= break/disp8
15872
15873 ff 0/subop/increment *(esi+4)
15874
15875 e9/jump $next-mu-token:done/disp32
15876 }
15877 {
15878 $next-mu-token:check-for-close-paren:
15879
15880 3d/compare-eax-and 0x29/imm32/close-paren
15881 75/jump-if-!= break/disp8
15882
15883 ff 0/subop/increment *(esi+4)
15884
15885 e9/jump $next-mu-token:done/disp32
15886 }
15887 {
15888 $next-mu-token:regular-word-without-metadata:
15889
15890
15891 8b/-> *(esi+4) 1/r32/ecx
15892
15893 3b/compare<- *esi 1/r32/ecx
15894 7d/jump-if->= break/disp8
15895
15896 31/xor-with %eax 0/r32/eax
15897 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL
15898
15899 3d/compare-eax-and 0x20/imm32/space
15900 74/jump-if-= break/disp8
15901
15902 3d/compare-eax-and 0xd/imm32/carriage-return
15903 74/jump-if-= break/disp8
15904
15905 3d/compare-eax-and 0xa/imm32/newline
15906 74/jump-if-= break/disp8
15907
15908 3d/compare-eax-and 0x28/imm32/open-paren
15909 0f 84/jump-if-= break/disp32
15910
15911 3d/compare-eax-and 0x29/imm32/close-paren
15912 0f 84/jump-if-= break/disp32
15913
15914 3d/compare-eax-and 0x2c/imm32/comma
15915 0f 84/jump-if-= break/disp32
15916
15917 ff 0/subop/increment *(esi+4)
15918
15919 e9/jump loop/disp32
15920 }
15921 $next-mu-token:done:
15922
15923 8b/-> *(esi+4) 1/r32/ecx
15924 8d/copy-address *(esi+ecx+0xc) 0/r32/eax
15925 89/<- *(edi+4) 0/r32/eax
15926 $next-mu-token:end:
15927
15928 5f/pop-to-edi
15929 5e/pop-to-esi
15930 59/pop-to-ecx
15931 58/pop-to-eax
15932
15933 89/<- %esp 5/r32/ebp
15934 5d/pop-to-ebp
15935 c3/return
15936
15937 pos-or-insert-slice:
15938
15939 55/push-ebp
15940 89/<- %ebp 4/r32/esp
15941
15942 (pos-slice *(ebp+8) *(ebp+0xc))
15943 3d/compare-eax-and -1/imm32
15944 75/jump-if-!= $pos-or-insert-slice:end/disp8
15945 $pos-or-insert-slice:insert:
15946
15947 68/push 0/imm32
15948 68/push 0/imm32
15949 89/<- %eax 4/r32/esp
15950 (slice-to-string Heap *(ebp+0xc) %eax)
15951
15952 (lookup *eax *(eax+4))
15953 (write-int *(ebp+8) %eax)
15954 (pos-slice *(ebp+8) *(ebp+0xc))
15955 $pos-or-insert-slice:end:
15956
15957 81 0/subop/add %esp 8/imm32
15958
15959 89/<- %esp 5/r32/ebp
15960 5d/pop-to-ebp
15961 c3/return
15962
15963
15964
15965 pos-slice:
15966
15967 55/push-ebp
15968 89/<- %ebp 4/r32/esp
15969
15970 51/push-ecx
15971 52/push-edx
15972 53/push-ebx
15973 56/push-esi
15974
15975
15976
15977
15978
15979 8b/-> *(ebp+8) 6/r32/esi
15980
15981 b9/copy-to-ecx 0/imm32
15982
15983 8d/copy-address *(esi+0xc) 2/r32/edx
15984
15985 8b/-> *esi 3/r32/ebx
15986 8d/copy-address *(esi+ebx+0xc) 3/r32/ebx
15987 {
15988
15989
15990
15991
15992
15993 39/compare %edx 3/r32/ebx
15994 b8/copy-to-eax -1/imm32
15995 73/jump-if-addr>= $pos-slice:end/disp8
15996
15997 (slice-equal? *(ebp+0xc) *edx)
15998 3d/compare-eax-and 0/imm32/false
15999 75/jump-if-!= break/disp8
16000
16001 41/increment-ecx
16002
16003 81 0/subop/add %edx 4/imm32
16004
16005 eb/jump loop/disp8
16006 }
16007
16008 89/<- %eax 1/r32/ecx
16009 $pos-slice:end:
16010
16011
16012
16013
16014 5e/pop-to-esi
16015 5b/pop-to-ebx
16016 5a/pop-to-edx
16017 59/pop-to-ecx
16018
16019 89/<- %esp 5/r32/ebp
16020 5d/pop-to-ebp
16021 c3/return
16022
16023 test-parse-var-with-type:
16024
16025 55/push-ebp
16026 89/<- %ebp 4/r32/esp
16027
16028 8b/-> *Primitive-type-ids 0/r32/eax
16029 89/<- *Type-id 0/r32/eax
16030
16031 b8/copy-to-eax "x:"/imm32
16032 8b/-> *eax 1/r32/ecx
16033 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16034 05/add-to-eax 4/imm32
16035
16036 51/push-ecx
16037 50/push-eax
16038 89/<- %ecx 4/r32/esp
16039
16040 (clear-stream _test-input-stream)
16041 (write _test-input-stream "int")
16042
16043 68/push 0/imm32
16044 68/push 0/imm32
16045 89/<- %edx 4/r32/esp
16046
16047 (parse-var-with-type %ecx _test-input-stream %edx 0 Stderr 0)
16048
16049 (lookup *edx *(edx+4))
16050 89/<- %edx 0/r32/eax
16051
16052 (lookup *edx *(edx+4))
16053 (check-strings-equal %eax "x" "F - test-parse-var-with-type/name")
16054
16055 (lookup *(edx+8) *(edx+0xc))
16056 (check-ints-equal *eax 1 "F - test-parse-var-with-type/type:0")
16057 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-type/type:1")
16058 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-type/type:2")
16059
16060 89/<- %esp 5/r32/ebp
16061 5d/pop-to-ebp
16062 c3/return
16063
16064 test-parse-var-with-type-and-register:
16065
16066 55/push-ebp
16067 89/<- %ebp 4/r32/esp
16068
16069 8b/-> *Primitive-type-ids 0/r32/eax
16070 89/<- *Type-id 0/r32/eax
16071
16072 b8/copy-to-eax "x/eax:"/imm32
16073 8b/-> *eax 1/r32/ecx
16074 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16075 05/add-to-eax 4/imm32
16076
16077 51/push-ecx
16078 50/push-eax
16079 89/<- %ecx 4/r32/esp
16080
16081 (clear-stream _test-input-stream)
16082 (write _test-input-stream "int")
16083
16084 68/push 0/imm32
16085 68/push 0/imm32
16086 89/<- %edx 4/r32/esp
16087
16088 (parse-var-with-type %ecx _test-input-stream %edx 0 Stderr 0)
16089
16090 (lookup *edx *(edx+4))
16091 89/<- %edx 0/r32/eax
16092
16093 (lookup *edx *(edx+4))
16094 (check-strings-equal %eax "x" "F - test-parse-var-with-type-and-register/name")
16095
16096 (lookup *(edx+0x18) *(edx+0x1c))
16097 (check-strings-equal %eax "eax" "F - test-parse-var-with-type-and-register/register")
16098
16099 (lookup *(edx+8) *(edx+0xc))
16100 (check-ints-equal *eax 1 "F - test-parse-var-with-type-and-register/type:0")
16101 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-type-and-register/type:1")
16102 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-type-and-register/type:2")
16103
16104 89/<- %esp 5/r32/ebp
16105 5d/pop-to-ebp
16106 c3/return
16107
16108 test-parse-var-with-trailing-characters:
16109
16110 55/push-ebp
16111 89/<- %ebp 4/r32/esp
16112
16113 8b/-> *Primitive-type-ids 0/r32/eax
16114 89/<- *Type-id 0/r32/eax
16115
16116 b8/copy-to-eax "x:"/imm32
16117 8b/-> *eax 1/r32/ecx
16118 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16119 05/add-to-eax 4/imm32
16120
16121 51/push-ecx
16122 50/push-eax
16123 89/<- %ecx 4/r32/esp
16124
16125 (clear-stream _test-input-stream)
16126 (write _test-input-stream "int,")
16127
16128 68/push 0/imm32
16129 68/push 0/imm32
16130 89/<- %edx 4/r32/esp
16131
16132 (parse-var-with-type %ecx _test-input-stream %edx 0 Stderr 0)
16133
16134 (lookup *edx *(edx+4))
16135 89/<- %edx 0/r32/eax
16136
16137 (lookup *edx *(edx+4))
16138 (check-strings-equal %eax "x" "F - test-parse-var-with-trailing-characters/name")
16139
16140 (check-ints-equal *(edx+0x18) 0 "F - test-parse-var-with-trailing-characters/register")
16141
16142 (lookup *(edx+8) *(edx+0xc))
16143 (check-ints-equal *eax 1 "F - test-parse-var-with-trailing-characters/type:0")
16144 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-trailing-characters/type:1")
16145 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-trailing-characters/type:1")
16146
16147 89/<- %esp 5/r32/ebp
16148 5d/pop-to-ebp
16149 c3/return
16150
16151 test-parse-var-with-register-and-trailing-characters:
16152
16153 55/push-ebp
16154 89/<- %ebp 4/r32/esp
16155
16156 8b/-> *Primitive-type-ids 0/r32/eax
16157 89/<- *Type-id 0/r32/eax
16158
16159 b8/copy-to-eax "x/eax:"/imm32
16160 8b/-> *eax 1/r32/ecx
16161 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16162 05/add-to-eax 4/imm32
16163
16164 51/push-ecx
16165 50/push-eax
16166 89/<- %ecx 4/r32/esp
16167
16168 (clear-stream _test-input-stream)
16169 (write _test-input-stream "int,")
16170
16171 68/push 0/imm32
16172 68/push 0/imm32
16173 89/<- %edx 4/r32/esp
16174
16175 (parse-var-with-type %ecx _test-input-stream %edx 0 Stderr 0)
16176
16177 (lookup *edx *(edx+4))
16178 89/<- %edx 0/r32/eax
16179
16180 (lookup *edx *(edx+4))
16181 (check-strings-equal %eax "x" "F - test-parse-var-with-register-and-trailing-characters/name")
16182
16183 (lookup *(edx+0x18) *(edx+0x1c))
16184 (check-strings-equal %eax "eax" "F - test-parse-var-with-register-and-trailing-characters/register")
16185
16186 (lookup *(edx+8) *(edx+0xc))
16187 (check-ints-equal *eax 1 "F - test-parse-var-with-register-and-trailing-characters/type:0")
16188 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-register-and-trailing-characters/type:1")
16189 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-register-and-trailing-characters/type:2")
16190
16191 89/<- %esp 5/r32/ebp
16192 5d/pop-to-ebp
16193 c3/return
16194
16195 test-parse-var-with-compound-type:
16196
16197 55/push-ebp
16198 89/<- %ebp 4/r32/esp
16199
16200 8b/-> *Primitive-type-ids 0/r32/eax
16201 89/<- *Type-id 0/r32/eax
16202
16203 b8/copy-to-eax "x:"/imm32
16204 8b/-> *eax 1/r32/ecx
16205 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16206 05/add-to-eax 4/imm32
16207
16208 51/push-ecx
16209 50/push-eax
16210 89/<- %ecx 4/r32/esp
16211
16212 (clear-stream _test-input-stream)
16213 (write _test-input-stream "(addr int)")
16214
16215 68/push 0/imm32
16216 68/push 0/imm32
16217 89/<- %edx 4/r32/esp
16218
16219 (parse-var-with-type %ecx _test-input-stream %edx 0 Stderr 0)
16220
16221 (lookup *edx *(edx+4))
16222 89/<- %edx 0/r32/eax
16223
16224 (lookup *edx *(edx+4))
16225 (check-strings-equal %eax "x" "F - test-parse-var-with-compound-type/name")
16226
16227 (check-ints-equal *(edx+0x18) 0 "F - test-parse-var-with-compound-type/register")
16228
16229
16230 (lookup *(edx+8) *(edx+0xc))
16231 89/<- %edx 0/r32/eax
16232
16233 (check-ints-equal *edx 0 "F - test-parse-var-with-compound-type/type:0")
16234
16235 (lookup *(edx+4) *(edx+8))
16236 (check-ints-equal *eax 1 "F - test-parse-var-with-compound-type/type:1")
16237 (check-ints-equal *(eax+4) 2 "F - test-parse-var-with-compound-type/type:2")
16238
16239 (lookup *(edx+0xc) *(edx+0x10))
16240 (lookup *(eax+4) *(eax+8))
16241 (check-ints-equal *eax 1 "F - test-parse-var-with-compound-type/type:3")
16242 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-compound-type/type:4")
16243
16244 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-compound-type/type:5")
16245
16246 89/<- %esp 5/r32/ebp
16247 5d/pop-to-ebp
16248 c3/return
16249
16250
16251
16252
16253 is-identifier?:
16254
16255 55/push-ebp
16256 89/<- %ebp 4/r32/esp
16257
16258 (slice-empty? *(ebp+8))
16259 3d/compare-eax-and 0/imm32/false
16260 75/jump-if-!= $is-identifier?:false/disp8
16261
16262 8b/-> *(ebp+8) 0/r32/eax
16263 8b/-> *eax 0/r32/eax
16264 8a/copy-byte *eax 0/r32/AL
16265 81 4/subop/and %eax 0xff/imm32
16266
16267 3d/compare-eax-and 0x24/imm32/$
16268 74/jump-if-= $is-identifier?:true/disp8
16269
16270 3d/compare-eax-and 0x5f/imm32/_
16271 74/jump-if-= $is-identifier?:true/disp8
16272
16273 25/and-eax-with 0x5f/imm32
16274
16275 3d/compare-eax-and 0x41/imm32/A
16276 7c/jump-if-< $is-identifier?:false/disp8
16277
16278 3d/compare-eax-and 0x5a/imm32/Z
16279 7f/jump-if-> $is-identifier?:false/disp8
16280
16281 $is-identifier?:true:
16282 b8/copy-to-eax 1/imm32/true
16283 eb/jump $is-identifier?:end/disp8
16284 $is-identifier?:false:
16285 b8/copy-to-eax 0/imm32/false
16286 $is-identifier?:end:
16287
16288 89/<- %esp 5/r32/ebp
16289 5d/pop-to-ebp
16290 c3/return
16291
16292 test-is-identifier-dollar:
16293
16294 55/push-ebp
16295 89/<- %ebp 4/r32/esp
16296
16297 b8/copy-to-eax "$a"/imm32
16298 8b/-> *eax 1/r32/ecx
16299 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16300 05/add-to-eax 4/imm32
16301
16302 51/push-ecx
16303 50/push-eax
16304 89/<- %ecx 4/r32/esp
16305
16306 (is-identifier? %ecx)
16307 (check-ints-equal %eax 1 "F - test-is-identifier-dollar")
16308
16309 89/<- %esp 5/r32/ebp
16310 5d/pop-to-ebp
16311 c3/return
16312
16313 test-is-identifier-underscore:
16314
16315 55/push-ebp
16316 89/<- %ebp 4/r32/esp
16317
16318 b8/copy-to-eax "_a"/imm32
16319 8b/-> *eax 1/r32/ecx
16320 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16321 05/add-to-eax 4/imm32
16322
16323 51/push-ecx
16324 50/push-eax
16325 89/<- %ecx 4/r32/esp
16326
16327 (is-identifier? %ecx)
16328 (check-ints-equal %eax 1 "F - test-is-identifier-underscore")
16329
16330 89/<- %esp 5/r32/ebp
16331 5d/pop-to-ebp
16332 c3/return
16333
16334 test-is-identifier-a:
16335
16336 55/push-ebp
16337 89/<- %ebp 4/r32/esp
16338
16339 b8/copy-to-eax "a$"/imm32
16340 8b/-> *eax 1/r32/ecx
16341 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16342 05/add-to-eax 4/imm32
16343
16344 51/push-ecx
16345 50/push-eax
16346 89/<- %ecx 4/r32/esp
16347
16348 (is-identifier? %ecx)
16349 (check-ints-equal %eax 1 "F - test-is-identifier-a")
16350
16351 89/<- %esp 5/r32/ebp
16352 5d/pop-to-ebp
16353 c3/return
16354
16355 test-is-identifier-z:
16356
16357 55/push-ebp
16358 89/<- %ebp 4/r32/esp
16359
16360 b8/copy-to-eax "z$"/imm32
16361 8b/-> *eax 1/r32/ecx
16362 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16363 05/add-to-eax 4/imm32
16364
16365 51/push-ecx
16366 50/push-eax
16367 89/<- %ecx 4/r32/esp
16368
16369 (is-identifier? %ecx)
16370 (check-ints-equal %eax 1 "F - test-is-identifier-z")
16371
16372 89/<- %esp 5/r32/ebp
16373 5d/pop-to-ebp
16374 c3/return
16375
16376 test-is-identifier-A:
16377
16378 55/push-ebp
16379 89/<- %ebp 4/r32/esp
16380
16381 b8/copy-to-eax "A$"/imm32
16382 8b/-> *eax 1/r32/ecx
16383 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16384 05/add-to-eax 4/imm32
16385
16386 51/push-ecx
16387 50/push-eax
16388 89/<- %ecx 4/r32/esp
16389
16390 (is-identifier? %ecx)
16391 (check-ints-equal %eax 1 "F - test-is-identifier-A")
16392
16393 89/<- %esp 5/r32/ebp
16394 5d/pop-to-ebp
16395 c3/return
16396
16397 test-is-identifier-Z:
16398
16399 55/push-ebp
16400 89/<- %ebp 4/r32/esp
16401
16402 b8/copy-to-eax "Z$"/imm32
16403 8b/-> *eax 1/r32/ecx
16404 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16405 05/add-to-eax 4/imm32
16406
16407 51/push-ecx
16408 50/push-eax
16409 89/<- %ecx 4/r32/esp
16410
16411 (is-identifier? %ecx)
16412 (check-ints-equal %eax 1 "F - test-is-identifier-Z")
16413
16414 89/<- %esp 5/r32/ebp
16415 5d/pop-to-ebp
16416 c3/return
16417
16418 test-is-identifier-at:
16419
16420
16421 55/push-ebp
16422 89/<- %ebp 4/r32/esp
16423
16424 b8/copy-to-eax "@a"/imm32
16425 8b/-> *eax 1/r32/ecx
16426 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16427 05/add-to-eax 4/imm32
16428
16429 51/push-ecx
16430 50/push-eax
16431 89/<- %ecx 4/r32/esp
16432
16433 (is-identifier? %ecx)
16434 (check-ints-equal %eax 0 "F - test-is-identifier-@")
16435
16436 89/<- %esp 5/r32/ebp
16437 5d/pop-to-ebp
16438 c3/return
16439
16440 test-is-identifier-square-bracket:
16441
16442
16443 55/push-ebp
16444 89/<- %ebp 4/r32/esp
16445
16446 b8/copy-to-eax "[a"/imm32
16447 8b/-> *eax 1/r32/ecx
16448 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16449 05/add-to-eax 4/imm32
16450
16451 51/push-ecx
16452 50/push-eax
16453 89/<- %ecx 4/r32/esp
16454
16455 (is-identifier? %ecx)
16456 (check-ints-equal %eax 0 "F - test-is-identifier-@")
16457
16458 89/<- %esp 5/r32/ebp
16459 5d/pop-to-ebp
16460 c3/return
16461
16462 test-is-identifier-backtick:
16463
16464
16465 55/push-ebp
16466 89/<- %ebp 4/r32/esp
16467
16468 b8/copy-to-eax "`a"/imm32
16469 8b/-> *eax 1/r32/ecx
16470 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16471 05/add-to-eax 4/imm32
16472
16473 51/push-ecx
16474 50/push-eax
16475 89/<- %ecx 4/r32/esp
16476
16477 (is-identifier? %ecx)
16478 (check-ints-equal %eax 0 "F - test-is-identifier-backtick")
16479
16480 89/<- %esp 5/r32/ebp
16481 5d/pop-to-ebp
16482 c3/return
16483
16484 test-is-identifier-curly-brace-open:
16485
16486
16487 55/push-ebp
16488 89/<- %ebp 4/r32/esp
16489
16490 b8/copy-to-eax "{a"/imm32
16491 8b/-> *eax 1/r32/ecx
16492 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16493 05/add-to-eax 4/imm32
16494
16495 51/push-ecx
16496 50/push-eax
16497 89/<- %ecx 4/r32/esp
16498
16499 (is-identifier? %ecx)
16500 (check-ints-equal %eax 0 "F - test-is-identifier-curly-brace-open")
16501
16502 89/<- %esp 5/r32/ebp
16503 5d/pop-to-ebp
16504 c3/return
16505
16506 test-is-identifier-curly-brace-close:
16507
16508 55/push-ebp
16509 89/<- %ebp 4/r32/esp
16510
16511 b8/copy-to-eax "}a"/imm32
16512 8b/-> *eax 1/r32/ecx
16513 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16514 05/add-to-eax 4/imm32
16515
16516 51/push-ecx
16517 50/push-eax
16518 89/<- %ecx 4/r32/esp
16519
16520 (is-identifier? %ecx)
16521 (check-ints-equal %eax 0 "F - test-is-identifier-curly-brace-close")
16522
16523 89/<- %esp 5/r32/ebp
16524 5d/pop-to-ebp
16525 c3/return
16526
16527 test-is-identifier-hyphen:
16528
16529
16530 55/push-ebp
16531 89/<- %ebp 4/r32/esp
16532
16533 b8/copy-to-eax "-a"/imm32
16534 8b/-> *eax 1/r32/ecx
16535 8d/copy-address *(eax+ecx+4) 1/r32/ecx
16536 05/add-to-eax 4/imm32
16537
16538 51/push-ecx
16539 50/push-eax
16540 89/<- %ecx 4/r32/esp
16541
16542 (is-identifier? %ecx)
16543 (check-ints-equal %eax 0 "F - test-is-identifier-hyphen")
16544
16545 89/<- %esp 5/r32/ebp
16546 5d/pop-to-ebp
16547 c3/return
16548
16549 populate-mu-function-body:
16550
16551 55/push-ebp
16552 89/<- %ebp 4/r32/esp
16553
16554 50/push-eax
16555 56/push-esi
16556 57/push-edi
16557
16558 8b/-> *(ebp+8) 6/r32/esi
16559
16560 8b/-> *(ebp+0xc) 7/r32/edi
16561
16562 c7 0/subop/copy *Curr-block-depth 1/imm32
16563
16564 8d/copy-address *(edi+0x18) 0/r32/eax
16565 (parse-mu-block %esi *(ebp+0x10) %edi %eax *(ebp+0x14) *(ebp+0x18))
16566 $populate-mu-function-body:end:
16567
16568 5f/pop-to-edi
16569 5e/pop-to-esi
16570 58/pop-to-eax
16571
16572 89/<- %esp 5/r32/ebp
16573 5d/pop-to-ebp
16574 c3/return
16575
16576
16577 parse-mu-block:
16578
16579
16580
16581
16582
16583
16584
16585
16586
16587
16588
16589
16590
16591
16592
16593
16594
16595
16596
16597
16598
16599
16600
16601
16602
16603
16604
16605
16606
16607
16608
16609
16610
16611
16612
16613
16614
16615 55/push-ebp
16616 89/<- %ebp 4/r32/esp
16617
16618 50/push-eax
16619 51/push-ecx
16620 52/push-edx
16621 53/push-ebx
16622 57/push-edi
16623
16624 81 5/subop/subtract %esp 0x200/imm32
16625 68/push 0x200/imm32/size
16626 68/push 0/imm32/read
16627 68/push 0/imm32/write
16628 89/<- %ecx 4/r32/esp
16629
16630 68/push 0/imm32/end
16631 68/push 0/imm32/start
16632 89/<- %edx 4/r32/esp
16633
16634 (allocate Heap *Stmt-size *(ebp+0x14))
16635
16636 8b/-> *(ebp+0x14) 7/r32/edi
16637 (lookup *edi *(edi+4))
16638 89/<- %edi 0/r32/eax
16639
16640
16641 8d/copy-address *(edi+0xc) 0/r32/eax
16642 (new-block-name *(ebp+0x10) %eax)
16643
16644 (push *(ebp+0xc) *(edi+0xc))
16645 (push *(ebp+0xc) *(edi+0x10))
16646 (push *(ebp+0xc) 0)
16647
16648 ff 0/subop/increment *Curr-block-depth
16649 {
16650 $parse-mu-block:line-loop:
16651
16652 (clear-stream %ecx)
16653 (read-line-buffered *(ebp+8) %ecx)
16654
16655
16656
16657
16658
16659
16660 81 7/subop/compare *ecx 0/imm32
16661 0f 84/jump-if-= break/disp32
16662
16663
16664
16665 (next-mu-token %ecx %edx)
16666
16667
16668
16669
16670
16671 (slice-empty? %edx)
16672 3d/compare-eax-and 0/imm32/false
16673 0f 85/jump-if-!= loop/disp32
16674
16675
16676 8b/-> *edx 0/r32/eax
16677 8a/copy-byte *eax 0/r32/AL
16678 81 4/subop/and %eax 0xff/imm32
16679
16680 3d/compare-eax-and 0x23/imm32/hash
16681 0f 84/jump-if-= loop/disp32
16682
16683 {
16684 $parse-mu-block:check-for-block:
16685 (slice-equal? %edx "{")
16686 3d/compare-eax-and 0/imm32/false
16687 74/jump-if-= break/disp8
16688 (check-no-tokens-left %ecx)
16689
16690
16691 68/push 0/imm32
16692 68/push 0/imm32
16693 89/<- %eax 4/r32/esp
16694
16695 (parse-mu-block *(ebp+8) *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c))
16696 (append-to-block Heap %edi *eax *(eax+4))
16697
16698 81 0/subop/add %esp 8/imm32
16699
16700 e9/jump $parse-mu-block:line-loop/disp32
16701 }
16702
16703 $parse-mu-block:check-for-end:
16704 (slice-equal? %edx "}")
16705 3d/compare-eax-and 0/imm32/false
16706 0f 85/jump-if-!= break/disp32
16707
16708 {
16709 $parse-mu-block:check-for-named-block:
16710
16711 8b/-> *(edx+4) 0/r32/eax
16712 48/decrement-eax
16713 8a/copy-byte *eax 0/r32/AL
16714 81 4/subop/and %eax 0xff/imm32
16715
16716 3d/compare-eax-and 0x3a/imm32/colon
16717 0f 85/jump-if-!= break/disp32
16718
16719
16720
16721 ff 1/subop/decrement *(edx+4)
16722
16723 68/push 0/imm32
16724 68/push 0/imm32
16725 89/<- %eax 4/r32/esp
16726
16727 (parse-mu-named-block %edx *(ebp+8) *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c))
16728 (append-to-block Heap %edi *eax *(eax+4))
16729
16730 81 0/subop/add %esp 8/imm32
16731
16732 e9/jump $parse-mu-block:line-loop/disp32
16733 }
16734
16735 {
16736 $parse-mu-block:check-for-var:
16737 (slice-equal? %edx "var")
16738 3d/compare-eax-and 0/imm32/false
16739 74/jump-if-= break/disp8
16740
16741 68/push 0/imm32
16742 68/push 0/imm32
16743 89/<- %eax 4/r32/esp
16744
16745 (parse-mu-var-def %ecx *(ebp+0xc) %eax *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c))
16746 (append-to-block Heap %edi *eax *(eax+4))
16747
16748 81 0/subop/add %esp 8/imm32
16749
16750 e9/jump $parse-mu-block:line-loop/disp32
16751 }
16752 $parse-mu-block:regular-stmt:
16753
16754
16755 68/push 0/imm32
16756 68/push 0/imm32
16757 89/<- %eax 4/r32/esp
16758
16759 (parse-mu-stmt %ecx *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c))
16760 (append-to-block Heap %edi *eax *(eax+4))
16761
16762 81 0/subop/add %esp 8/imm32
16763
16764 e9/jump loop/disp32
16765 }
16766 (clean-up-blocks *(ebp+0xc) *Curr-block-depth *(ebp+0x10))
16767
16768 ff 1/subop/decrement *Curr-block-depth
16769
16770 (pop *(ebp+0xc))
16771 (pop *(ebp+0xc))
16772 (pop *(ebp+0xc))
16773 $parse-mu-block:end:
16774
16775 81 0/subop/add %esp 0x214/imm32
16776
16777 5f/pop-to-edi
16778 5b/pop-to-ebx
16779 5a/pop-to-edx
16780 59/pop-to-ecx
16781 58/pop-to-eax
16782
16783 89/<- %esp 5/r32/ebp
16784 5d/pop-to-ebp
16785 c3/return
16786
16787 $parse-mu-block:abort:
16788
16789 (write-buffered *(ebp+0x18) "'{' or '}' should be on its own line, but got '")
16790 (rewind-stream %ecx)
16791 (write-stream-data *(ebp+0x18) %ecx)
16792 (write-buffered *(ebp+0x18) "'\n")
16793 (flush *(ebp+0x18))
16794 (stop *(ebp+0x1c) 1)
16795
16796
16797 new-block-name:
16798
16799 55/push-ebp
16800 89/<- %ebp 4/r32/esp
16801
16802 50/push-eax
16803 51/push-ecx
16804 52/push-edx
16805
16806 8b/-> *(ebp+8) 0/r32/eax
16807 (lookup *eax *(eax+4))
16808 8b/-> *eax 0/r32/eax
16809 05/add-to-eax 0xd/imm32
16810 89/<- %ecx 0/r32/eax
16811
16812 29/subtract-from %esp 1/r32/ecx
16813 ff 6/subop/push %ecx
16814 68/push 0/imm32/read
16815 68/push 0/imm32/write
16816 89/<- %edx 4/r32/esp
16817 (clear-stream %edx)
16818
16819 8b/-> *(ebp+8) 0/r32/eax
16820 (lookup *eax *(eax+4))
16821
16822 (write %edx "$")
16823 (write %edx %eax)
16824 (write %edx ":")
16825 (write-int32-hex %edx *Next-block-index)
16826 ff 0/subop/increment *Next-block-index
16827
16828
16829 8b/-> *edx 0/r32/eax
16830
16831 8d/copy-address *(edx+0xc) 2/r32/edx
16832
16833 01/add-to %eax 2/r32/edx
16834
16835 ff 6/subop/push %eax
16836 ff 6/subop/push %edx
16837 89/<- %eax 4/r32/esp
16838
16839 (new-literal Heap %eax *(ebp+0xc))
16840
16841
16842
16843
16844
16845
16846
16847 $new-block-name:end:
16848
16849 81 0/subop/add %ecx 0xc/imm32
16850 81 0/subop/add %ecx 8/imm32
16851 01/add-to %esp 1/r32/ecx
16852
16853 5a/pop-to-edx
16854 59/pop-to-ecx
16855 58/pop-to-eax
16856
16857 89/<- %esp 5/r32/ebp
16858 5d/pop-to-ebp
16859 c3/return
16860
16861 check-no-tokens-left:
16862
16863 55/push-ebp
16864 89/<- %ebp 4/r32/esp
16865
16866 50/push-eax
16867 51/push-ecx
16868
16869 68/push 0/imm32/end
16870 68/push 0/imm32/start
16871 89/<- %ecx 4/r32/esp
16872
16873 (next-mu-token *(ebp+8) %ecx)
16874
16875 (slice-empty? %ecx)
16876 3d/compare-eax-and 0/imm32/false
16877 75/jump-if-!= $check-no-tokens-left:end/disp8
16878
16879
16880 8b/-> *edx 0/r32/eax
16881 8a/copy-byte *eax 0/r32/AL
16882 81 4/subop/and %eax 0xff/imm32
16883
16884 3d/compare-eax-and 0x23/imm32/hash
16885 74/jump-if-= $check-no-tokens-left:end/disp8
16886
16887 (write-buffered Stderr "'{' or '}' should be on its own line, but got '")
16888 (rewind-stream %ecx)
16889 (write-stream 2 %ecx)
16890 (write-buffered Stderr "'\n")
16891 (flush Stderr)
16892
16893 bb/copy-to-ebx 1/imm32
16894 e8/call syscall_exit/disp32
16895
16896 $check-no-tokens-left:end:
16897
16898 81 0/subop/add %esp 8/imm32
16899
16900 59/pop-to-ecx
16901 58/pop-to-eax
16902
16903 89/<- %esp 5/r32/ebp
16904 5d/pop-to-ebp
16905 c3/return
16906
16907 parse-mu-named-block:
16908
16909
16910
16911
16912
16913
16914
16915
16916
16917
16918 55/push-ebp
16919 89/<- %ebp 4/r32/esp
16920
16921 50/push-eax
16922 51/push-ecx
16923 57/push-edi
16924
16925 68/push 0/imm32
16926 68/push 0/imm32
16927 89/<- %ecx 4/r32/esp
16928
16929 (new-literal Heap *(ebp+8) %ecx)
16930
16931 (push *(ebp+0x10) *ecx)
16932 (push *(ebp+0x10) *(ecx+4))
16933 (push *(ebp+0x10) 0)
16934
16935 (parse-mu-block *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c) *(ebp+0x20))
16936
16937 (pop *(ebp+0x10))
16938 (pop *(ebp+0x10))
16939 (pop *(ebp+0x10))
16940
16941 8b/-> *(ebp+0x18) 7/r32/edi
16942 (lookup *edi *(edi+4))
16943 89/<- %edi 0/r32/eax
16944
16945 c7 0/subop/copy *edi 0/imm32/block
16946
16947 8b/-> *ecx 0/r32/eax
16948 89/<- *(edi+0xc) 0/r32/eax
16949 8b/-> *(ecx+4) 0/r32/eax
16950 89/<- *(edi+0x10) 0/r32/eax
16951 $parse-mu-named-block:end:
16952
16953 81 0/subop/add %esp 8/imm32
16954
16955 5f/pop-to-edi
16956 59/pop-to-ecx
16957 58/pop-to-eax
16958
16959 89/<- %esp 5/r32/ebp
16960 5d/pop-to-ebp
16961 c3/return
16962
16963 parse-mu-var-def:
16964
16965 55/push-ebp
16966 89/<- %ebp 4/r32/esp
16967
16968 50/push-eax
16969 51/push-ecx
16970 52/push-edx
16971 56/push-esi
16972 57/push-edi
16973
16974 8b/-> *(ebp+0x10) 7/r32/edi
16975
16976 68/push 0/imm32/end
16977 68/push 0/imm32/start
16978 89/<- %ecx 4/r32/esp
16979
16980 68/push 0/imm32
16981 68/push 0/imm32
16982 89/<- %edx 4/r32/esp
16983
16984 (next-mu-token *(ebp+8) %ecx)
16985 {
16986
16987 8b/-> *(ebp+0x14) 0/r32/eax
16988 3d/compare-eax-and 0/imm32
16989 74/jump-if-= break/disp8
16990 (lookup *eax *(eax+4))
16991 }
16992 (parse-var-with-type %ecx *(ebp+8) %edx %eax *(ebp+0x18) *(ebp+0x1c))
16993
16994 (lookup *edx *(edx+4))
16995 89/<- %esi 0/r32/eax
16996
16997 8b/-> *Curr-block-depth 0/r32/eax
16998 89/<- *(esi+0x10) 0/r32/eax
16999
17000 81 7/subop/compare *(esi+0x18) 0/imm32
17001 {
17002 75/jump-if-!= break/disp8
17003
17004 (lookup *(esi+8) *(esi+0xc))
17005 (is-simple-mu-type? %eax 8)
17006 3d/compare-eax-and 0/imm32/false
17007 0f 85/jump-if-!= $parse-mu-var-def:error-byte-on-stack/disp32
17008
17009 (next-mu-token *(ebp+8) %ecx)
17010 (slice-empty? %ecx)
17011 3d/compare-eax-and 0/imm32/false
17012 0f 84/jump-if-= $parse-mu-var-def:error2/disp32
17013
17014 (new-var-def Heap *edx *(edx+4) %edi)
17015 e9/jump $parse-mu-var-def:update-vars/disp32
17016 }
17017
17018 {
17019 0f 84/jump-if-= break/disp32
17020
17021 {
17022 (lookup *(esi+8) *(esi+0xc))
17023 (is-simple-mu-type? %eax 8)
17024 3d/compare-eax-and 0/imm32/false
17025 74/jump-if-= break/disp8
17026 (lookup *(esi+0x18) *(esi+0x1c))
17027 (string-equal? %eax "esi")
17028 3d/compare-eax-and 0/imm32/false
17029 0f 85/jump-if-!= $parse-mu-var-def:error-byte-registers/disp32
17030 (lookup *(esi+0x18) *(esi+0x1c))
17031 (string-equal? %eax "edi")
17032 3d/compare-eax-and 0/imm32/false
17033 0f 85/jump-if-!= $parse-mu-var-def:error-byte-registers/disp32
17034 }
17035
17036
17037 (next-mu-token *(ebp+8) %ecx)
17038 (slice-equal? %ecx "<-")
17039 3d/compare-eax-and 0/imm32/false
17040 0f 84/jump-if-= $parse-mu-var-def:error1/disp32
17041
17042 (new-reg-var-def Heap *edx *(edx+4) %edi)
17043 (lookup *edi *(edi+4))
17044 (add-operation-and-inputs-to-stmt %eax *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c))
17045 }
17046 $parse-mu-var-def:update-vars:
17047
17048 (push *(ebp+0xc) *edx)
17049 (push *(ebp+0xc) *(edx+4))
17050 (push *(ebp+0xc) 0)
17051 $parse-mu-var-def:end:
17052
17053 81 0/subop/add %esp 0x10/imm32
17054
17055 5f/pop-to-edi
17056 5e/pop-to-esi
17057 5a/pop-to-edx
17058 59/pop-to-ecx
17059 58/pop-to-eax
17060
17061 89/<- %esp 5/r32/ebp
17062 5d/pop-to-ebp
17063 c3/return
17064
17065 $parse-mu-var-def:error1:
17066 (rewind-stream *(ebp+8))
17067
17068 (write-buffered *(ebp+0x18) "register variable requires a valid instruction to initialize but got '")
17069 (flush *(ebp+0x18))
17070 (write-stream-data *(ebp+0x18) *(ebp+8))
17071 (write-buffered *(ebp+0x18) "'\n")
17072 (flush *(ebp+0x18))
17073 (stop *(ebp+0x1c) 1)
17074
17075
17076 $parse-mu-var-def:error2:
17077
17078 (write-buffered *(ebp+0x18) "fn ")
17079 8b/-> *(ebp+0x14) 0/r32/eax
17080 (lookup *eax *(eax+4))
17081 (write-buffered *(ebp+0x18) %eax)
17082 (write-buffered *(ebp+0x18) ": var ")
17083
17084 (lookup *edx *(edx+4))
17085 (lookup *eax *(eax+4))
17086 (write-buffered *(ebp+0x18) %eax)
17087 (write-buffered *(ebp+0x18) ": variables on the stack can't take an initializer\n")
17088 (flush *(ebp+0x18))
17089 (stop *(ebp+0x1c) 1)
17090
17091
17092 $parse-mu-var-def:error-byte-on-stack:
17093
17094 (write-buffered *(ebp+0x18) "fn ")
17095 8b/-> *(ebp+0x14) 0/r32/eax
17096 (lookup *eax *(eax+4))
17097 (write-buffered *(ebp+0x18) %eax)
17098 (write-buffered *(ebp+0x18) ": var '")
17099
17100 (lookup *edx *(edx+4))
17101 (lookup *eax *(eax+4))
17102 (write-buffered *(ebp+0x18) %eax)
17103 (write-buffered *(ebp+0x18) "' of type 'byte' cannot be on the stack\n")
17104 (flush *(ebp+0x18))
17105 (stop *(ebp+0x1c) 1)
17106
17107
17108 $parse-mu-var-def:error-byte-registers:
17109
17110 (write-buffered *(ebp+0x18) "fn ")
17111 8b/-> *(ebp+0x14) 0/r32/eax
17112 (lookup *eax *(eax+4))
17113 (write-buffered *(ebp+0x18) %eax)
17114 (write-buffered *(ebp+0x18) ": var '")
17115
17116 (lookup *edx *(edx+4))
17117 (lookup *eax *(eax+4))
17118 (write-buffered *(ebp+0x18) %eax)
17119 (write-buffered *(ebp+0x18) "' of type 'byte' cannot be in esi or edi\n")
17120 (flush *(ebp+0x18))
17121 (stop *(ebp+0x1c) 1)
17122
17123
17124 test-parse-mu-var-def:
17125
17126
17127 55/push-ebp
17128 89/<- %ebp 4/r32/esp
17129
17130 8b/-> *Primitive-type-ids 0/r32/eax
17131 89/<- *Type-id 0/r32/eax
17132 (clear-stream _test-input-stream)
17133 (write _test-input-stream "n: int\n")
17134 c7 0/subop/copy *Curr-block-depth 1/imm32
17135
17136 68/push 0/imm32
17137 68/push 0/imm32
17138 89/<- %esi 4/r32/esp
17139
17140 81 5/subop/subtract %esp 0xc0/imm32
17141 68/push 0xc0/imm32/size
17142 68/push 0/imm32/top
17143 89/<- %ecx 4/r32/esp
17144 (clear-stack %ecx)
17145
17146 (parse-mu-var-def _test-input-stream %ecx %esi 0 Stderr 0)
17147
17148 (lookup *esi *(esi+4))
17149 89/<- %esi 0/r32/eax
17150
17151 (check-ints-equal *esi 2 "F - test-parse-mu-var-def/tag")
17152
17153 (lookup *(esi+4) *(esi+8))
17154 89/<- %ecx 0/r32/eax
17155
17156 (lookup *ecx *(ecx+4))
17157 (check-strings-equal %eax "n" "F - test-parse-mu-var-def/var-name")
17158
17159 (check-ints-equal *(ecx+0x18) 0 "F - test-parse-mu-var-def/var-register")
17160
17161 (check-ints-equal *(ecx+0x10) 1 "F - test-parse-mu-var-def/output-block-depth")
17162
17163 (lookup *(ecx+8) *(ecx+0xc))
17164 (check-ints-equal *eax 1 "F - test-parse-mu-var-def/var-type:0")
17165 (check-ints-equal *(eax+4) 1 "F - test-parse-mu-var-def/var-type:1")
17166 (check-ints-equal *(eax+0xc) 0 "F - test-parse-mu-var-def/var-type:2")
17167
17168 89/<- %esp 5/r32/ebp
17169 5d/pop-to-ebp
17170 c3/return
17171
17172 test-parse-mu-reg-var-def:
17173
17174
17175 55/push-ebp
17176 89/<- %ebp 4/r32/esp
17177
17178 8b/-> *Primitive-type-ids 0/r32/eax
17179 89/<- *Type-id 0/r32/eax
17180 (clear-stream _test-input-stream)
17181 (write _test-input-stream "n/eax: int <- copy 0\n")
17182 c7 0/subop/copy *Curr-block-depth 1/imm32
17183
17184 68/push 0/imm32
17185 68/push 0/imm32
17186 89/<- %esi 4/r32/esp
17187
17188 81 5/subop/subtract %esp 0xc0/imm32
17189 68/push 0xc0/imm32/size
17190 68/push 0/imm32/top
17191 89/<- %ecx 4/r32/esp
17192 (clear-stack %ecx)
17193
17194 (parse-mu-var-def _test-input-stream %ecx %esi 0 Stderr 0)
17195
17196 (lookup *esi *(esi+4))
17197 89/<- %esi 0/r32/eax
17198
17199 (check-ints-equal *esi 3 "F - test-parse-mu-reg-var-def/tag")
17200
17201
17202 (lookup *(esi+0x14) *(esi+0x18))
17203
17204 (check-ints-equal *(eax+8) 0 "F - test-parse-mu-reg-var-def/single-output")
17205
17206 (lookup *eax *(eax+4))
17207
17208 89/<- %ecx 0/r32/eax
17209
17210 (lookup *ecx *(ecx+4))
17211 (check-strings-equal %eax "n" "F - test-parse-mu-reg-var-def/output-name")
17212
17213 (lookup *(ecx+0x18) *(ecx+0x1c))
17214 (check-strings-equal %eax "eax" "F - test-parse-mu-reg-var-def/output-register")
17215
17216 (check-ints-equal *(ecx+0x10) 1 "F - test-parse-mu-reg-var-def/output-block-depth")
17217
17218 (lookup *(ecx+8) *(ecx+0xc))
17219 (check-ints-equal *eax 1 "F - test-parse-mu-reg-var-def/output-type:0")
17220 (check-ints-equal *(eax+4) 1 "F - test-parse-mu-reg-var-def/output-type:1")
17221 (check-ints-equal *(eax+0xc) 0 "F - test-parse-mu-reg-var-def/output-type:2")
17222
17223 89/<- %esp 5/r32/ebp
17224 5d/pop-to-ebp
17225 c3/return
17226
17227 parse-mu-stmt:
17228
17229
17230
17231
17232
17233
17234
17235
17236
17237
17238
17239
17240
17241
17242
17243 55/push-ebp
17244 89/<- %ebp 4/r32/esp
17245
17246 50/push-eax
17247 51/push-ecx
17248 52/push-edx
17249 53/push-ebx
17250 57/push-edi
17251
17252 68/push 0/imm32/end
17253 68/push 0/imm32/start
17254 89/<- %ecx 4/r32/esp
17255
17256 ba/copy-to-edx 0/imm32/false
17257
17258 68/push 0/imm32
17259 68/push 0/imm32
17260 89/<- %ebx 4/r32/esp
17261
17262 (allocate Heap *Stmt-size *(ebp+0x14))
17263
17264 8b/-> *(ebp+0x14) 7/r32/edi
17265 (lookup *edi *(edi+4))
17266 89/<- %edi 0/r32/eax
17267
17268 c7 0/subop/copy *edi 1/imm32/stmt1
17269 {
17270 (stmt-has-outputs? *(ebp+8))
17271 3d/compare-eax-and 0/imm32/false
17272 0f 84/jump-if-= break/disp32
17273 {
17274 $parse-mu-stmt:read-outputs:
17275
17276 (next-mu-token *(ebp+8) %ecx)
17277
17278 (slice-empty? %ecx)
17279 3d/compare-eax-and 0/imm32/false
17280 0f 85/jump-if-!= break/disp32
17281
17282 (slice-equal? %ecx "<-")
17283 3d/compare-eax-and 0/imm32/false
17284 0f 85/jump-if-!= break/disp32
17285
17286 8b/-> *ecx 0/r32/eax
17287 8a/copy-byte *eax 0/r32/AL
17288 81 4/subop/and %eax 0xff/imm32
17289 3d/compare-eax-and 0x2a/imm32/asterisk
17290 0f 84/jump-if-= $parse-mu-stmt:error-output-dereferenced/disp32
17291
17292 (is-identifier? %ecx)
17293 3d/compare-eax-and 0/imm32/false
17294 0f 84/jump-if-= $parse-mu-stmt:abort/disp32
17295
17296 (lookup-var %ecx *(ebp+0xc) %ebx *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c))
17297 8d/copy-address *(edi+0x14) 0/r32/eax
17298 (append-stmt-var Heap *ebx *(ebx+4) *(edi+0x14) *(edi+0x18) 0 %eax)
17299
17300 e9/jump loop/disp32
17301 }
17302 }
17303 (add-operation-and-inputs-to-stmt %edi *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c))
17304 $parse-mu-stmt:end:
17305
17306 81 0/subop/add %esp 0x10/imm32
17307
17308 5f/pop-to-edi
17309 5b/pop-to-ebx
17310 5a/pop-to-edx
17311 59/pop-to-ecx
17312 58/pop-to-eax
17313
17314 89/<- %esp 5/r32/ebp
17315 5d/pop-to-ebp
17316 c3/return
17317
17318 $parse-mu-stmt:abort:
17319
17320 (write-buffered *(ebp+0x18) "fn ")
17321 8b/-> *(ebp+0x10) 0/r32/eax
17322 (lookup *eax *(eax+4))
17323 (write-buffered *(ebp+0x18) %eax)
17324 (write-buffered *(ebp+0x18) ": invalid identifier '")
17325 (write-slice-buffered *(ebp+0x18) %ecx)
17326 (write-buffered *(ebp+0x18) "'\n")
17327 (flush *(ebp+0x18))
17328 (stop *(ebp+0x1c) 1)
17329
17330
17331 $parse-mu-stmt:error-output-dereferenced:
17332
17333 (write-buffered *(ebp+0x18) "fn ")
17334 8b/-> *(ebp+0x10) 0/r32/eax
17335 (lookup *eax *(eax+4))
17336 (write-buffered *(ebp+0x18) %eax)
17337 (write-buffered *(ebp+0x18) ": output '")
17338 (write-slice-buffered *(ebp+0x18) %ecx)
17339 (write-buffered *(ebp+0x18) "' should write to a register, and therefore cannot be dereferenced\n")
17340 (flush *(ebp+0x18))
17341 (stop *(ebp+0x1c) 1)
17342
17343
17344 add-operation-and-inputs-to-stmt:
17345
17346
17347
17348
17349
17350
17351
17352
17353 55/push-ebp
17354 89/<- %ebp 4/r32/esp
17355
17356 50/push-eax
17357 51/push-ecx
17358 52/push-edx
17359 53/push-ebx
17360 56/push-esi
17361 57/push-edi
17362
17363 8b/-> *(ebp+8) 7/r32/edi
17364
17365 68/push 0/imm32/end
17366 68/push 0/imm32/start
17367 89/<- %ecx 4/r32/esp
17368
17369 ba/copy-to-edx 0/imm32/false
17370
17371 68/push 0/imm32
17372 68/push 0/imm32
17373 89/<- %esi 4/r32/esp
17374 $add-operation-and-inputs-to-stmt:read-operation:
17375 (next-mu-token *(ebp+0xc) %ecx)
17376 8d/copy-address *(edi+4) 0/r32/eax
17377 (slice-to-string Heap %ecx %eax)
17378
17379 (slice-equal? %ecx "get")
17380 89/<- %ebx 0/r32/eax
17381 {
17382 $add-operation-and-inputs-to-stmt:read-inouts:
17383
17384 (next-mu-token *(ebp+0xc) %ecx)
17385
17386 (slice-empty? %ecx)
17387 3d/compare-eax-and 0/imm32/false
17388 0f 85/jump-if-!= break/disp32
17389
17390 (slice-equal? %ecx "<-")
17391 3d/compare-eax-and 0/imm32/false
17392 0f 85/jump-if-!= $add-operation-and-inputs-to-stmt:abort/disp32
17393
17394 {
17395 81 7/subop/compare %ebx 0/imm32/false
17396 74/jump-if-= break/disp8
17397 (lookup *(edi+0xc) *(edi+0x10))
17398 3d/compare-eax-and 0/imm32
17399 74/jump-if-= break/disp8
17400 (lookup-or-create-constant %eax %ecx %esi)
17401
17402
17403
17404
17405
17406
17407
17408
17409
17410
17411 e9/jump $add-operation-and-inputs-to-stmt:save-var/disp32
17412 }
17413
17414 ba/copy-to-edx 0/imm32/false
17415
17416 8b/-> *ecx 0/r32/eax
17417 8a/copy-byte *eax 0/r32/AL
17418 81 4/subop/and %eax 0xff/imm32
17419 3d/compare-eax-and 0x2a/imm32/asterisk
17420 {
17421 75/jump-if-!= break/disp8
17422 $add-operation-and-inputs-to-stmt:inout-is-deref:
17423 ff 0/subop/increment *ecx
17424 ba/copy-to-edx 1/imm32/true
17425 }
17426 (lookup-var-or-literal %ecx *(ebp+0x10) %esi *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c))
17427
17428 81 7/subop/compare %edx 0/imm32/false
17429 {
17430 74/jump-if-= break/disp8
17431
17432 (lookup *esi *(esi+4))
17433 81 7/subop/compare *(eax+0x18) 0/imm32
17434 0f 84/jump-if-= $add-operation-and-inputs-to-stmt:error-deref-on-stack/disp32
17435
17436 (lookup *(eax+8) *(eax+0xc))
17437 (is-mu-addr-type? %eax)
17438 3d/compare-eax-and 0/imm32/false
17439 0f 84/jump-if-= $add-operation-and-inputs-to-stmt:error-deref-non-addr/disp32
17440 }
17441 $add-operation-and-inputs-to-stmt:save-var:
17442 8d/copy-address *(edi+0xc) 0/r32/eax
17443 (append-stmt-var Heap *esi *(esi+4) *(edi+0xc) *(edi+0x10) %edx %eax)
17444
17445 e9/jump loop/disp32
17446 }
17447 $add-operation-and-inputs-to-stmt:end:
17448
17449 81 0/subop/add %esp 0x10/imm32
17450
17451 5f/pop-to-edi
17452 5e/pop-to-esi
17453 5b/pop-to-ebx
17454 5a/pop-to-edx
17455 59/pop-to-ecx
17456 58/pop-to-eax
17457
17458 89/<- %esp 5/r32/ebp
17459 5d/pop-to-ebp
17460 c3/return
17461
17462 $add-operation-and-inputs-to-stmt:abort:
17463
17464 (write-buffered *(ebp+0x18) "fn ")
17465 8b/-> *(ebp+0x14) 0/r32/eax
17466 (lookup *eax *(eax+4))
17467 (write-buffered *(ebp+0x18) %eax)
17468 (rewind-stream *(ebp+0xc))
17469 (write-buffered *(ebp+0x18) ": invalid identifier in '")
17470 (write-stream-data *(ebp+0x18) *(ebp+0xc))
17471 (write-buffered *(ebp+0x18) "'\n")
17472 (flush *(ebp+0x18))
17473 (stop *(ebp+0x1c) 1)
17474
17475
17476 $add-operation-and-inputs-to-stmt:error-deref-on-stack:
17477
17478 (write-buffered *(ebp+0x18) "fn ")
17479 8b/-> *(ebp+0x14) 0/r32/eax
17480 (lookup *eax *(eax+4))
17481 (write-buffered *(ebp+0x18) %eax)
17482 (rewind-stream *(ebp+0xc))
17483 (write-buffered *(ebp+0x18) ": cannot dereference var '")
17484 (lookup *esi *(esi+4))
17485 (lookup *eax *(eax+4))
17486 (write-buffered *(ebp+0x18) %eax)
17487 (write-buffered *(ebp+0x18) "' on stack\n")
17488 (flush *(ebp+0x18))
17489 (stop *(ebp+0x1c) 1)
17490
17491
17492 $add-operation-and-inputs-to-stmt:error-deref-non-addr:
17493
17494 (write-buffered *(ebp+0x18) "fn ")
17495 8b/-> *(ebp+0x14) 0/r32/eax
17496 (lookup *eax *(eax+4))
17497 (write-buffered *(ebp+0x18) %eax)
17498 (rewind-stream *(ebp+0xc))
17499 (write-buffered *(ebp+0x18) ": cannot dereference non-addr var '")
17500 (lookup *esi *(esi+4))
17501 (lookup *eax *(eax+4))
17502 (write-buffered *(ebp+0x18) %eax)
17503 (write-buffered *(ebp+0x18) "'\n")
17504 (flush *(ebp+0x18))
17505 (stop *(ebp+0x1c) 1)
17506
17507
17508 stmt-has-outputs?:
17509
17510 55/push-ebp
17511 89/<- %ebp 4/r32/esp
17512
17513 51/push-ecx
17514
17515 68/push 0/imm32/end
17516 68/push 0/imm32/start
17517 89/<- %ecx 4/r32/esp
17518
17519 b8/copy-to-eax 0/imm32/false
17520 (rewind-stream *(ebp+8))
17521 {
17522 (next-mu-token *(ebp+8) %ecx)
17523
17524 (slice-empty? %ecx)
17525 3d/compare-eax-and 0/imm32/false
17526 b8/copy-to-eax 0/imm32/false/result
17527 0f 85/jump-if-!= break/disp32
17528
17529
17530 8b/-> *ecx 0/r32/eax
17531 8a/copy-byte *eax 0/r32/AL
17532 81 4/subop/and %eax 0xff/imm32
17533
17534 3d/compare-eax-and 0x23/imm32/hash
17535 b8/copy-to-eax 0/imm32/false/result
17536 0f 84/jump-if-= break/disp32
17537
17538 (slice-equal? %ecx "<-")
17539 3d/compare-eax-and 0/imm32/false
17540 74/jump-if-= loop/disp8
17541 b8/copy-to-eax 1/imm32/true
17542 }
17543 $stmt-has-outputs:end:
17544 (rewind-stream *(ebp+8))
17545
17546 81 0/subop/add %esp 8/imm32
17547
17548 59/pop-to-ecx
17549
17550 89/<- %esp 5/r32/ebp
17551 5d/pop-to-ebp
17552 c3/return
17553
17554
17555
17556 lookup-var-or-literal:
17557
17558 55/push-ebp
17559 89/<- %ebp 4/r32/esp
17560
17561 50/push-eax
17562 51/push-ecx
17563 56/push-esi
17564
17565 8b/-> *(ebp+8) 6/r32/esi
17566
17567 (slice-empty? %esi)
17568 3d/compare-eax-and 0/imm32/false
17569 0f 85/jump-if-!= $lookup-var-or-literal:abort/disp32
17570
17571 8b/-> *esi 1/r32/ecx
17572 8a/copy-byte *ecx 1/r32/CL
17573 81 4/subop/and %ecx 0xff/imm32
17574
17575 {
17576 81 7/subop/compare %ecx 0x2d/imm32/dash
17577 74/jump-if-= $lookup-var-or-literal:literal/disp8
17578 (is-decimal-digit? %ecx)
17579 3d/compare-eax-and 0/imm32/false
17580 74/jump-if-= break/disp8
17581 $lookup-var-or-literal:literal:
17582 (new-literal-integer Heap %esi *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c))
17583 eb/jump $lookup-var-or-literal:end/disp8
17584 }
17585
17586 {
17587 81 7/subop/compare %ecx 0x22/imm32/dquote
17588 75/jump-if-!= break/disp8
17589 $lookup-var-or-literal:literal-string:
17590 (new-literal-string Heap %esi *(ebp+0x10))
17591 eb/jump $lookup-var-or-literal:end/disp8
17592 }
17593
17594 {
17595 $lookup-var-or-literal:var:
17596 (lookup-var %esi *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c))
17597 }
17598 $lookup-var-or-literal:end:
17599
17600 5e/pop-to-esi
17601 59/pop-to-ecx
17602 58/pop-to-eax
17603
17604 89/<- %esp 5/r32/ebp
17605 5d/pop-to-ebp
17606 c3/return
17607
17608 $lookup-var-or-literal:abort:
17609 (write-buffered *(ebp+0x18) "fn ")
17610 8b/-> *(ebp+0x14) 0/r32/eax
17611 (lookup *eax *(eax+4))
17612 (write-buffered *(ebp+0x18) %eax)
17613 (write-buffered *(ebp+0x18) ": empty variable!")
17614 (flush *(ebp+0x18))
17615 (stop *(ebp+0x1c) 1)
17616
17617
17618
17619 lookup-var:
17620
17621 55/push-ebp
17622 89/<- %ebp 4/r32/esp
17623
17624 50/push-eax
17625
17626 (lookup-var-helper *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c))
17627
17628 8b/-> *(ebp+0x10) 0/r32/eax
17629 81 7/subop/compare *eax 0/imm32
17630 74/jump-if-= $lookup-var:abort/disp8
17631 $lookup-var:end:
17632
17633 58/pop-to-eax
17634
17635 89/<- %esp 5/r32/ebp
17636 5d/pop-to-ebp
17637 c3/return
17638
17639 $lookup-var:abort:
17640 (write-buffered *(ebp+0x18) "fn ")
17641 8b/-> *(ebp+0x14) 0/r32/eax
17642 (lookup *eax *(eax+4))
17643 (write-buffered *(ebp+0x18) %eax)
17644 (write-buffered *(ebp+0x18) ": unknown variable '")
17645 (write-slice-buffered *(ebp+0x18) *(ebp+8))
17646 (write-buffered *(ebp+0x18) "'\n")
17647 (flush *(ebp+0x18))
17648 (stop *(ebp+0x1c) 1)
17649
17650
17651
17652
17653 lookup-var-helper:
17654
17655
17656
17657
17658
17659
17660
17661
17662
17663
17664 55/push-ebp
17665 89/<- %ebp 4/r32/esp
17666
17667 50/push-eax
17668 51/push-ecx
17669 52/push-edx
17670 53/push-ebx
17671 56/push-esi
17672 57/push-edi
17673
17674 (zero-out *(ebp+0x10) *Handle-size)
17675
17676 8b/-> *(ebp+0xc) 6/r32/esi
17677
17678 8b/-> *esi 3/r32/ebx
17679
17680 3b/compare<- *(esi+4) 0/r32/eax
17681 0f 8f/jump-if-> $lookup-var-helper:error1/disp32
17682
17683 8d/copy-address *(esi+8) 2/r32/edx
17684
17685 8d/copy-address *(esi+ebx-4) 3/r32/ebx
17686
17687 68/push 0/imm32
17688 68/push 0/imm32
17689 68/push 0/imm32
17690 68/push 0/imm32
17691 68/push 0/imm32
17692 68/push 0/imm32
17693 68/push 0/imm32
17694 68/push 0/imm32
17695 68/push 0/imm32
17696 68/push 0/imm32
17697 68/push 0/imm32
17698 68/push 0/imm32
17699 68/push 0/imm32
17700 68/push 0/imm32
17701 68/push 0/imm32
17702 68/push 0/imm32
17703 89/<- %edi 4/r32/esp
17704 {
17705 $lookup-var-helper:loop:
17706
17707 39/compare %ebx 2/r32/edx
17708 0f 82/jump-if-addr< break/disp32
17709
17710 (lookup *ebx *(ebx+4))
17711 89/<- %ecx 0/r32/eax
17712
17713 (lookup *ecx *(ecx+4))
17714
17715 (slice-equal? *(ebp+8) %eax)
17716 3d/compare-eax-and 0/imm32/false
17717 {
17718 74/jump-if-= break/disp8
17719 $lookup-var-helper:found:
17720
17721 (lookup *(ecx+0x18) *(ecx+0x1c))
17722 3d/compare-eax-and 0/imm32
17723 {
17724 74/jump-if-= break/disp8
17725 $lookup-var-helper:found-register:
17726
17727 (get Mu-registers-unique %eax 0xc "Mu-registers-unique")
17728 8b/-> *eax 0/r32/eax
17729
17730 8b/-> *(edi+eax<<2) 0/r32/eax
17731 3d/compare-eax-and 0/imm32
17732 0f 85/jump-if-!= $lookup-var-helper:error2/disp32
17733 }
17734 $lookup-var-helper:return:
17735
17736 8b/-> *(ebp+0x10) 6/r32/esi
17737
17738 8b/-> *ebx 0/r32/eax
17739 89/<- *esi 0/r32/eax
17740 8b/-> *(ebx+4) 0/r32/eax
17741 89/<- *(esi+4) 0/r32/eax
17742
17743 eb/jump $lookup-var-helper:end/disp8
17744 }
17745
17746
17747 (lookup *(ecx+0x18) *(ecx+0x1c))
17748
17749 3d/compare-eax-and 0/imm32
17750 74/jump-if-= $lookup-var-helper:continue/disp8
17751
17752 (get Mu-registers-unique %eax 0xc "Mu-registers-unique")
17753 8b/-> *eax 0/r32/eax
17754
17755 89/<- *(edi+eax<<2) 1/r32/ecx
17756 $lookup-var-helper:continue:
17757
17758 81 5/subop/subtract %ebx 0xc/imm32
17759 e9/jump loop/disp32
17760 }
17761 $lookup-var-helper:end:
17762
17763 81 0/subop/add %esp 0x40/imm32
17764
17765 5f/pop-to-edi
17766 5e/pop-to-esi
17767 5b/pop-to-ebx
17768 5a/pop-to-edx
17769 59/pop-to-ecx
17770 58/pop-to-eax
17771
17772 89/<- %esp 5/r32/ebp
17773 5d/pop-to-ebp
17774 c3/return
17775
17776 $lookup-var-helper:error1:
17777 (write-buffered *(ebp+0x18) "fn ")
17778 8b/-> *(ebp+0x14) 0/r32/eax
17779 (lookup *eax *(eax+4))
17780 (write-buffered *(ebp+0x18) %eax)
17781 (write-buffered *(ebp+0x18) ": malformed stack when looking up '")
17782 (write-slice-buffered *(ebp+0x18) *(ebp+8))
17783 (write-buffered *(ebp+0x18) "'\n")
17784 (flush *(ebp+0x18))
17785 (stop *(ebp+0x1c) 1)
17786
17787
17788 $lookup-var-helper:error2:
17789
17790 (write-buffered *(ebp+0x18) "fn ")
17791 50/push-eax
17792 8b/-> *(ebp+0x14) 0/r32/eax
17793 (lookup *eax *(eax+4))
17794 (write-buffered *(ebp+0x18) %eax)
17795 58/pop-eax
17796 (write-buffered *(ebp+0x18) ": register ")
17797 50/push-eax
17798 (lookup *(eax+0x18) *(eax+0x1c))
17799 (write-buffered *(ebp+0x18) %eax)
17800 58/pop-to-eax
17801 (write-buffered *(ebp+0x18) " reads var '")
17802 (write-slice-buffered *(ebp+0x18) *(ebp+8))
17803 (write-buffered *(ebp+0x18) "' after writing var '")
17804 (lookup *eax *(eax+4))
17805 (write-buffered *(ebp+0x18) %eax)
17806 (write-buffered *(ebp+0x18) "'\n")
17807 (flush *(ebp+0x18))
17808 (stop *(ebp+0x1c) 1)
17809
17810
17811 dump-vars:
17812
17813
17814
17815
17816
17817
17818
17819
17820
17821 55/push-ebp
17822 89/<- %ebp 4/r32/esp
17823
17824 52/push-edx
17825 53/push-ebx
17826 56/push-esi
17827
17828 8b/-> *(ebp+8) 6/r32/esi
17829
17830 8b/-> *esi 3/r32/ebx
17831
17832 8d/copy-address *(esi+8) 2/r32/edx
17833
17834 8d/copy-address *(esi+ebx-4) 3/r32/ebx
17835 {
17836 $dump-vars:loop:
17837
17838 39/compare %ebx 2/r32/edx
17839 0f 82/jump-if-addr< break/disp32
17840
17841 (write-buffered Stderr " var@")
17842 (dump-var 2 %ebx)
17843
17844 81 5/subop/subtract %ebx 0xc/imm32
17845 e9/jump loop/disp32
17846 }
17847 $dump-vars:end:
17848
17849 5e/pop-to-esi
17850 5b/pop-to-ebx
17851 5a/pop-to-edx
17852
17853 89/<- %esp 5/r32/ebp
17854 5d/pop-to-ebp
17855 c3/return
17856
17857 == data
17858
17859 Mu-registers:
17860
17861 0xa8/imm32/write
17862 0/imm32/read
17863 0xa8/imm32/length
17864
17865
17866
17867 0x11/imm32/alloc-id $Mu-register-eax/imm32 0/imm32
17868 0x11/imm32/alloc-id $Mu-register-ecx/imm32 1/imm32
17869 0x11/imm32/alloc-id $Mu-register-edx/imm32 2/imm32
17870 0x11/imm32/alloc-id $Mu-register-ebx/imm32 3/imm32
17871 0x11/imm32/alloc-id $Mu-register-esi/imm32 6/imm32
17872 0x11/imm32/alloc-id $Mu-register-edi/imm32 7/imm32
17873
17874 0x11/imm32/alloc-id $Mu-register-xmm0/imm32 0/imm32
17875 0x11/imm32/alloc-id $Mu-register-xmm1/imm32 1/imm32
17876 0x11/imm32/alloc-id $Mu-register-xmm2/imm32 2/imm32
17877 0x11/imm32/alloc-id $Mu-register-xmm3/imm32 3/imm32
17878 0x11/imm32/alloc-id $Mu-register-xmm4/imm32 4/imm32
17879 0x11/imm32/alloc-id $Mu-register-xmm5/imm32 5/imm32
17880 0x11/imm32/alloc-id $Mu-register-xmm6/imm32 6/imm32
17881 0x11/imm32/alloc-id $Mu-register-xmm7/imm32 7/imm32
17882
17883
17884
17885
17886 Mu-registers-unique:
17887
17888 0xa8/imm32/write
17889 0/imm32/read
17890 0xa8/imm32/length
17891
17892
17893 0x11/imm32/alloc-id $Mu-register-eax/imm32 0/imm32
17894 0x11/imm32/alloc-id $Mu-register-ecx/imm32 1/imm32
17895 0x11/imm32/alloc-id $Mu-register-edx/imm32 2/imm32
17896 0x11/imm32/alloc-id $Mu-register-ebx/imm32 3/imm32
17897 0x11/imm32/alloc-id $Mu-register-esi/imm32 6/imm32
17898 0x11/imm32/alloc-id $Mu-register-edi/imm32 7/imm32
17899
17900 0x11/imm32/alloc-id $Mu-register-xmm0/imm32 8/imm32
17901 0x11/imm32/alloc-id $Mu-register-xmm1/imm32 9/imm32
17902 0x11/imm32/alloc-id $Mu-register-xmm2/imm32 0xa/imm32
17903 0x11/imm32/alloc-id $Mu-register-xmm3/imm32 0xb/imm32
17904 0x11/imm32/alloc-id $Mu-register-xmm4/imm32 0xc/imm32
17905 0x11/imm32/alloc-id $Mu-register-xmm5/imm32 0xd/imm32
17906 0x11/imm32/alloc-id $Mu-register-xmm6/imm32 0xe/imm32
17907 0x11/imm32/alloc-id $Mu-register-xmm7/imm32 0xf/imm32
17908
17909 $Mu-register-eax:
17910 0x11/imm32/alloc-id
17911 3/imm32/size
17912 0x65/e 0x61/a 0x78/x
17913
17914 $Mu-register-ecx:
17915 0x11/imm32/alloc-id
17916 3/imm32/size
17917 0x65/e 0x63/c 0x78/x
17918
17919 $Mu-register-edx:
17920 0x11/imm32/alloc-id
17921 3/imm32/size
17922 0x65/e 0x64/d 0x78/x
17923
17924 $Mu-register-ebx:
17925 0x11/imm32/alloc-id
17926 3/imm32/size
17927 0x65/e 0x62/b 0x78/x
17928
17929 $Mu-register-esi:
17930 0x11/imm32/alloc-id
17931 3/imm32/size
17932 0x65/e 0x73/s 0x69/i
17933
17934 $Mu-register-edi:
17935 0x11/imm32/alloc-id
17936 3/imm32/size
17937 0x65/e 0x64/d 0x69/i
17938
17939 $Mu-register-xmm0:
17940 0x11/imm32/alloc-id:fake:payload
17941
17942 0x4/imm32/size
17943 0x78/x 0x6d/m 0x6d/m 0x30/0
17944
17945 $Mu-register-xmm1:
17946 0x11/imm32/alloc-id:fake:payload
17947
17948 0x4/imm32/size
17949 0x78/x 0x6d/m 0x6d/m 0x31/1
17950
17951 $Mu-register-xmm2:
17952 0x11/imm32/alloc-id:fake:payload
17953
17954 0x4/imm32/size
17955 0x78/x 0x6d/m 0x6d/m 0x32/2
17956
17957 $Mu-register-xmm3:
17958 0x11/imm32/alloc-id:fake:payload
17959
17960 0x4/imm32/size
17961 0x78/x 0x6d/m 0x6d/m 0x33/3
17962
17963 $Mu-register-xmm4:
17964 0x11/imm32/alloc-id:fake:payload
17965
17966 0x4/imm32/size
17967 0x78/x 0x6d/m 0x6d/m 0x34/4
17968
17969 $Mu-register-xmm5:
17970 0x11/imm32/alloc-id:fake:payload
17971
17972 0x4/imm32/size
17973 0x78/x 0x6d/m 0x6d/m 0x35/5
17974
17975 $Mu-register-xmm6:
17976 0x11/imm32/alloc-id:fake:payload
17977
17978 0x4/imm32/size
17979 0x78/x 0x6d/m 0x6d/m 0x36/6
17980
17981 $Mu-register-xmm7:
17982 0x11/imm32/alloc-id:fake:payload
17983
17984 0x4/imm32/size
17985 0x78/x 0x6d/m 0x6d/m 0x37/7
17986
17987 == code
17988
17989
17990 maybe-define-var:
17991
17992 55/push-ebp
17993 89/<- %ebp 4/r32/esp
17994
17995 50/push-eax
17996
17997 (lookup *(ebp+8) *(ebp+0xc))
17998
17999 (binding-exists? %eax *(ebp+0x10))
18000 3d/compare-eax-and 0/imm32/false
18001 75/jump-if-!= $maybe-define-var:end/disp8
18002
18003 (push *(ebp+0x10) *(ebp+8))
18004 (push *(ebp+0x10) *(ebp+0xc))
18005 (push *(ebp+0x10) 0)
18006 $maybe-define-var:end:
18007
18008 58/pop-to-eax
18009
18010 89/<- %esp 5/r32/ebp
18011 5d/pop-to-ebp
18012 c3/return
18013
18014
18015 binding-exists?:
18016
18017
18018
18019
18020
18021
18022
18023
18024
18025
18026
18027 55/push-ebp
18028 89/<- %ebp 4/r32/esp
18029
18030 51/push-ecx
18031 52/push-edx
18032 56/push-esi
18033
18034 8b/-> *(ebp+8) 0/r32/eax
18035 (lookup *eax *(eax+4))
18036 89/<- %ecx 0/r32/eax
18037
18038 8b/-> *(ebp+0xc) 6/r32/esi
18039
18040 8b/-> *esi 0/r32/eax
18041
18042 8d/copy-address *(esi+8) 2/r32/edx
18043
18044 8d/copy-address *(esi+eax-4) 6/r32/esi
18045 {
18046 $binding-exists?:loop:
18047
18048 39/compare %esi 2/r32/edx
18049 0f 82/jump-if-addr< break/disp32
18050
18051 (lookup *esi *(esi+4))
18052
18053 (lookup *eax *(eax+4))
18054
18055 (string-equal? %ecx %eax)
18056 3d/compare-eax-and 0/imm32/false
18057 75/jump-if-!= $binding-exists?:end/disp8
18058
18059 81 5/subop/subtract %esi 0xc/imm32
18060 e9/jump loop/disp32
18061 }
18062 b8/copy-to-eax 0/imm32/false
18063 $binding-exists?:end:
18064
18065 5e/pop-to-esi
18066 5a/pop-to-edx
18067 59/pop-to-ecx
18068
18069 89/<- %esp 5/r32/ebp
18070 5d/pop-to-ebp
18071 c3/return
18072
18073 test-parse-mu-stmt:
18074
18075 55/push-ebp
18076 89/<- %ebp 4/r32/esp
18077
18078 8b/-> *Primitive-type-ids 0/r32/eax
18079 89/<- *Type-id 0/r32/eax
18080 (clear-stream _test-input-stream)
18081 (write _test-input-stream "increment n\n")
18082
18083 81 5/subop/subtract %esp 0xc0/imm32
18084 68/push 0xc0/imm32/size
18085 68/push 0/imm32/top
18086 89/<- %ecx 4/r32/esp
18087 (clear-stack %ecx)
18088
18089 68/push 0/imm32
18090 68/push 0/imm32
18091 89/<- %edx 4/r32/esp
18092
18093 68/push 0/imm32
18094 68/push 0/imm32
18095 89/<- %eax 4/r32/esp
18096
18097 (copy-array Heap "n" %eax)
18098 (new-var Heap *eax *(eax+4) %edx)
18099
18100 (push %ecx *edx)
18101 (push %ecx *(edx+4))
18102 (push %ecx 0)
18103
18104 68/push 0/imm32
18105 68/push 0/imm32
18106 89/<- %eax 4/r32/esp
18107
18108 (parse-mu-stmt _test-input-stream %ecx 0 %eax Stderr 0)
18109
18110 (lookup *eax *(eax+4))
18111 89/<- %edx 0/r32/eax
18112
18113 (check-ints-equal *edx 1 "F - test-parse-mu-stmt/tag")
18114
18115 (lookup *(edx+4) *(edx+8))
18116 (check-strings-equal %eax "increment" "F - test-parse-mu-stmt/name")
18117
18118
18119 (lookup *(edx+0xc) *(edx+0x10))
18120
18121 (lookup *eax *(eax+4))
18122
18123 (lookup *eax *(eax+4))
18124
18125 (check-strings-equal %eax "n" "F - test-parse-mu-stmt/inout:0")
18126
18127 89/<- %esp 5/r32/ebp
18128 5d/pop-to-ebp
18129 c3/return
18130
18131 test-parse-mu-stmt-with-comma:
18132
18133 55/push-ebp
18134 89/<- %ebp 4/r32/esp
18135
18136 8b/-> *Primitive-type-ids 0/r32/eax
18137 89/<- *Type-id 0/r32/eax
18138 (clear-stream _test-input-stream)
18139 (write _test-input-stream "copy-to n, 3\n")
18140
18141 81 5/subop/subtract %esp 0xc0/imm32
18142 68/push 0xc0/imm32/size
18143 68/push 0/imm32/top
18144 89/<- %ecx 4/r32/esp
18145 (clear-stack %ecx)
18146
18147 68/push 0/imm32
18148 68/push 0/imm32
18149 89/<- %edx 4/r32/esp
18150
18151 68/push 0/imm32
18152 68/push 0/imm32
18153 89/<- %eax 4/r32/esp
18154
18155 (copy-array Heap "n" %eax)
18156 (new-var Heap *eax *(eax+4) %edx)
18157
18158 (push %ecx *edx)
18159 (push %ecx *(edx+4))
18160 (push %ecx 0)
18161
18162 68/push 0/imm32
18163 68/push 0/imm32
18164 89/<- %eax 4/r32/esp
18165
18166 (parse-mu-stmt _test-input-stream %ecx 0 %eax Stderr 0)
18167
18168 (lookup *eax *(eax+4))
18169 89/<- %edx 0/r32/eax
18170
18171 (check-ints-equal *edx 1 "F - test-parse-mu-stmt-with-comma/tag")
18172
18173 (lookup *(edx+4) *(edx+8))
18174 (check-strings-equal %eax "copy-to" "F - test-parse-mu-stmt-with-comma/name")
18175
18176
18177 (lookup *(edx+0xc) *(edx+0x10))
18178
18179 (lookup *eax *(eax+4))
18180
18181 (lookup *eax *(eax+4))
18182
18183 (check-strings-equal %eax "n" "F - test-parse-mu-stmt-with-comma/inout:0")
18184
18185 89/<- %esp 5/r32/ebp
18186 5d/pop-to-ebp
18187 c3/return
18188
18189 new-var:
18190
18191 55/push-ebp
18192 89/<- %ebp 4/r32/esp
18193
18194 50/push-eax
18195 51/push-ecx
18196
18197 8b/-> *(ebp+0x14) 1/r32/ecx
18198
18199 (allocate *(ebp+8) *Var-size %ecx)
18200
18201 (lookup *ecx *(ecx+4))
18202
18203 8b/-> *(ebp+0xc) 1/r32/ecx
18204 89/<- *eax 1/r32/ecx
18205 8b/-> *(ebp+0x10) 1/r32/ecx
18206 89/<- *(eax+4) 1/r32/ecx
18207
18208
18209
18210
18211
18212
18213
18214
18215
18216 $new-var:end:
18217
18218 59/pop-to-ecx
18219 58/pop-to-eax
18220
18221 89/<- %esp 5/r32/ebp
18222 5d/pop-to-ebp
18223 c3/return
18224
18225 new-literal-integer:
18226
18227 55/push-ebp
18228 89/<- %ebp 4/r32/esp
18229
18230 50/push-eax
18231 51/push-ecx
18232
18233 (is-hex-int? *(ebp+0xc))
18234 3d/compare-eax-and 0/imm32/false
18235 0f 84/jump-if-= $new-literal-integer:abort/disp32
18236
18237 (check-mu-hex-int *(ebp+0xc) *(ebp+0x18) *(ebp+0x1c))
18238
18239 (new-var-from-slice *(ebp+8) *(ebp+0xc) *(ebp+0x10))
18240
18241 8b/-> *(ebp+0x10) 0/r32/eax
18242 (lookup *eax *(eax+4))
18243 89/<- %ecx 0/r32/eax
18244
18245 8b/-> *Curr-block-depth 0/r32/eax
18246 89/<- *(ecx+0x10) 0/r32/eax
18247
18248 8d/copy-address *(ecx+8) 0/r32/eax
18249 (allocate *(ebp+8) *Type-tree-size %eax)
18250 (lookup *(ecx+8) *(ecx+0xc))
18251 c7 0/subop/copy *eax 1/imm32/true
18252
18253 $new-literal-integer:end:
18254
18255 81 0/subop/add %esp 8/imm32
18256
18257 59/pop-to-ecx
18258 58/pop-to-eax
18259
18260 89/<- %esp 5/r32/ebp
18261 5d/pop-to-ebp
18262 c3/return
18263
18264 $new-literal-integer:abort:
18265 (write-buffered *(ebp+0x18) "fn ")
18266 8b/-> *(ebp+0x14) 0/r32/eax
18267 (lookup *eax *(eax+4))
18268 (write-buffered *(ebp+0x18) %eax)
18269 (write-buffered *(ebp+0x18) ": variable '")
18270 (write-slice-buffered *(ebp+0x18) *(ebp+0xc))
18271 (write-buffered *(ebp+0x18) "' cannot begin with a digit (or do you have a typo in a number?)\n")
18272 (flush *(ebp+0x18))
18273 (stop *(ebp+0x1c) 1)
18274
18275
18276
18277 check-mu-hex-int:
18278
18279 55/push-ebp
18280 89/<- %ebp 4/r32/esp
18281
18282 50/push-eax
18283 51/push-ecx
18284 52/push-edx
18285
18286 8b/-> *(ebp+8) 1/r32/ecx
18287
18288 8b/-> *ecx 2/r32/edx
18289
18290 b8/copy-to-eax 0/imm32
18291 8a/copy-byte *edx 0/r32/AL
18292 3d/compare-eax-and 0x2d/imm32/dash
18293 {
18294 75/jump-if-!= break/disp8
18295 42/increment-edx
18296 }
18297
18298 8b/-> *(ecx+4) 1/r32/ecx
18299
18300 89/<- %eax 1/r32/ecx
18301 29/subtract-from %eax 2/r32/edx
18302
18303 3d/compare-eax-with 1/imm32
18304 0f 8e/jump-if-<= $check-mu-hex-int:end/disp32
18305 $check-mu-hex-int:length->-1:
18306
18307
18308 51/push-ecx
18309 52/push-edx
18310 89/<- %eax 4/r32/esp
18311
18312 (slice-starts-with? %eax "0x")
18313
18314 81 0/subop/add %esp 8/imm32
18315
18316 3d/compare-eax-with 0/imm32/false
18317 75/jump-if-!= $check-mu-hex-int:end/disp8
18318 $check-mu-hex-int:abort:
18319
18320 (write-buffered *(ebp+0xc) "literal integers are always hex in Mu; start '")
18321 (write-slice-buffered *(ebp+0xc) *(ebp+8))
18322 (write-buffered *(ebp+0xc) "' with a '0x' to be unambiguous, converting it to hexadecimal as necessary.\n")
18323 (flush *(ebp+0xc))
18324 (stop *(ebp+0x10) 1)
18325 $check-mu-hex-int:end:
18326
18327 5a/pop-to-edx
18328 59/pop-to-ecx
18329 58/pop-to-eax
18330
18331 89/<- %esp 5/r32/ebp
18332 5d/pop-to-ebp
18333 c3/return
18334
18335 new-literal:
18336
18337 55/push-ebp
18338 89/<- %ebp 4/r32/esp
18339
18340 50/push-eax
18341 51/push-ecx
18342
18343 68/push 0/imm32
18344 68/push 0/imm32
18345 89/<- %ecx 4/r32/esp
18346
18347 (slice-to-string Heap *(ebp+0xc) %ecx)
18348
18349 (new-var *(ebp+8) *ecx *(ecx+4) *(ebp+0x10))
18350
18351 8b/-> *(ebp+0x10) 1/r32/ecx
18352 (lookup *ecx *(ecx+4))
18353 89/<- %ecx 0/r32/eax
18354
18355 8b/-> *Curr-block-depth 0/r32/eax
18356 89/<- *(ecx+0x10) 0/r32/eax
18357
18358 8d/copy-address *(ecx+8) 0/r32/eax
18359 (allocate *(ebp+8) *Type-tree-size %eax)
18360 (lookup *(ecx+8) *(ecx+0xc))
18361
18362 c7 0/subop/copy *eax 1/imm32/true
18363 $new-literal:end:
18364
18365 81 0/subop/add %esp 8/imm32
18366
18367 59/pop-to-ecx
18368 58/pop-to-eax
18369
18370 89/<- %esp 5/r32/ebp
18371 5d/pop-to-ebp
18372 c3/return
18373
18374 new-literal-string:
18375
18376 55/push-ebp
18377 89/<- %ebp 4/r32/esp
18378
18379 50/push-eax
18380 51/push-ecx
18381
18382 68/push 0/imm32
18383 68/push 0/imm32
18384 89/<- %ecx 4/r32/esp
18385
18386 (slice-to-string Heap *(ebp+0xc) %ecx)
18387
18388 (new-var *(ebp+8) *ecx *(ecx+4) *(ebp+0x10))
18389
18390 8b/-> *(ebp+0x10) 1/r32/ecx
18391 (lookup *ecx *(ecx+4))
18392 89/<- %ecx 0/r32/eax
18393
18394 8b/-> *Curr-block-depth 0/r32/eax
18395 89/<- *(ecx+0x10) 0/r32/eax
18396
18397 8d/copy-address *(ecx+8) 0/r32/eax
18398 (allocate *(ebp+8) *Type-tree-size %eax)
18399 (lookup *(ecx+8) *(ecx+0xc))
18400
18401 c7 0/subop/copy *(eax+4) 0x10/imm32/type-id-string-literal
18402
18403 c7 0/subop/copy *eax 1/imm32/true
18404 $new-literal-string:end:
18405
18406 81 0/subop/add %esp 8/imm32
18407
18408 59/pop-to-ecx
18409 58/pop-to-eax
18410
18411 89/<- %esp 5/r32/ebp
18412 5d/pop-to-ebp
18413 c3/return
18414
18415 new-var-from-slice:
18416
18417 55/push-ebp
18418 89/<- %ebp 4/r32/esp
18419
18420 51/push-ecx
18421
18422 68/push 0/imm32
18423 68/push 0/imm32
18424 89/<- %ecx 4/r32/esp
18425
18426 (slice-to-string Heap *(ebp+0xc) %ecx)
18427
18428 (new-var *(ebp+8) *ecx *(ecx+4) *(ebp+0x10))
18429 $new-var-from-slice:end:
18430
18431 81 0/subop/add %esp 8/imm32
18432
18433 59/pop-to-ecx
18434
18435 89/<- %esp 5/r32/ebp
18436 5d/pop-to-ebp
18437 c3/return
18438
18439 new-var-def:
18440
18441 55/push-ebp
18442 89/<- %ebp 4/r32/esp
18443
18444 50/push-eax
18445 51/push-ecx
18446
18447 (allocate *(ebp+8) *Stmt-size *(ebp+0x14))
18448
18449 8b/-> *(ebp+0x14) 0/r32/eax
18450 (lookup *eax *(eax+4))
18451
18452 c7 0/subop/copy *eax 2/imm32/tag/var-on-stack
18453
18454 8b/-> *(ebp+0xc) 1/r32/ecx
18455 89/<- *(eax+4) 1/r32/ecx
18456 8b/-> *(ebp+0x10) 1/r32/ecx
18457 89/<- *(eax+8) 1/r32/ecx
18458 $new-var-def:end:
18459
18460 59/pop-to-ecx
18461 58/pop-to-eax
18462
18463 89/<- %esp 5/r32/ebp
18464 5d/pop-to-ebp
18465 c3/return
18466
18467 new-reg-var-def:
18468
18469 55/push-ebp
18470 89/<- %ebp 4/r32/esp
18471
18472 50/push-eax
18473
18474 8b/-> *(ebp+0x14) 0/r32/eax
18475
18476 (allocate *(ebp+8) *Stmt-size %eax)
18477
18478 (lookup *eax *(eax+4))
18479
18480 c7 0/subop/copy *eax 3/imm32/tag/var-in-register
18481
18482 8d/copy-address *(eax+0x14) 0/r32/eax
18483 (append-stmt-var Heap *(ebp+0xc) *(ebp+0x10) 0 0 0 %eax)
18484 $new-reg-var-def:end:
18485
18486 58/pop-to-eax
18487
18488 89/<- %esp 5/r32/ebp
18489 5d/pop-to-ebp
18490 c3/return
18491
18492 append-list:
18493
18494 55/push-ebp
18495 89/<- %ebp 4/r32/esp
18496
18497 50/push-eax
18498 51/push-ecx
18499 57/push-edi
18500
18501 8b/-> *(ebp+0x1c) 7/r32/edi
18502
18503 (allocate *(ebp+8) *List-size %edi)
18504
18505 (lookup *edi *(edi+4))
18506 89/<- %edi 0/r32/eax
18507
18508 8b/-> *(ebp+0xc) 0/r32/eax
18509 89/<- *edi 0/r32/eax
18510 8b/-> *(ebp+0x10) 0/r32/eax
18511 89/<- *(edi+4) 0/r32/eax
18512
18513 81 7/subop/compare *(ebp+0x14) 0/imm32
18514 74/jump-if-= $append-list:end/disp8
18515
18516 $append-list:non-empty-list:
18517
18518 (lookup *(ebp+0x14) *(ebp+0x18))
18519
18520 {
18521 81 7/subop/compare *(eax+8) 0/imm32
18522 74/jump-if-= break/disp8
18523
18524 (lookup *(eax+8) *(eax+0xc))
18525
18526 eb/jump loop/disp8
18527 }
18528
18529 8b/-> *(ebp+0x1c) 7/r32/edi
18530
18531 8b/-> *edi 1/r32/ecx
18532 89/<- *(eax+8) 1/r32/ecx
18533 8b/-> *(edi+4) 1/r32/ecx
18534 89/<- *(eax+0xc) 1/r32/ecx
18535
18536 8b/-> *(ebp+0x14) 1/r32/ecx
18537 89/<- *edi 1/r32/ecx
18538 8b/-> *(ebp+0x18) 1/r32/ecx
18539 89/<- *(edi+4) 1/r32/ecx
18540 $append-list:end:
18541
18542 5f/pop-to-edi
18543 59/pop-to-ecx
18544 58/pop-to-eax
18545
18546 89/<- %esp 5/r32/ebp
18547 5d/pop-to-ebp
18548 c3/return
18549
18550 append-stmt-var:
18551
18552 55/push-ebp
18553 89/<- %ebp 4/r32/esp
18554
18555 50/push-eax
18556 51/push-ecx
18557 57/push-edi
18558
18559 8b/-> *(ebp+0x20) 7/r32/edi
18560
18561 (allocate *(ebp+8) *Stmt-var-size %edi)
18562
18563 (lookup *edi *(edi+4))
18564 89/<- %ecx 0/r32/eax
18565
18566 8b/-> *(ebp+0xc) 0/r32/eax
18567 89/<- *ecx 0/r32/eax
18568 8b/-> *(ebp+0x10) 0/r32/eax
18569 89/<- *(ecx+4) 0/r32/eax
18570
18571 8b/-> *(ebp+0x1c) 0/r32/eax
18572 89/<- *(ecx+0x10) 0/r32/eax
18573
18574 81 7/subop/compare *(ebp+0x14) 0/imm32/null
18575 74/jump-if-= $append-stmt-var:end/disp8
18576
18577
18578 (lookup *(ebp+0x14) *(ebp+0x18))
18579
18580 {
18581 81 7/subop/compare *(eax+8) 0/imm32
18582 74/jump-if-= break/disp8
18583
18584 (lookup *(eax+8) *(eax+0xc))
18585
18586 eb/jump loop/disp8
18587 }
18588
18589 8b/-> *edi 1/r32/ecx
18590 89/<- *(eax+8) 1/r32/ecx
18591 8b/-> *(edi+4) 1/r32/ecx
18592 89/<- *(eax+0xc) 1/r32/ecx
18593
18594 8b/-> *(ebp+0x14) 1/r32/ecx
18595 89/<- *edi 1/r32/ecx
18596 8b/-> *(ebp+0x18) 1/r32/ecx
18597 89/<- *(edi+4) 1/r32/ecx
18598 $append-stmt-var:end:
18599
18600 5f/pop-to-edi
18601 59/pop-to-ecx
18602 58/pop-to-eax
18603
18604 89/<- %esp 5/r32/ebp
18605 5d/pop-to-ebp
18606 c3/return
18607
18608 append-to-block:
18609
18610 55/push-ebp
18611 89/<- %ebp 4/r32/esp
18612
18613 50/push-eax
18614 56/push-esi
18615
18616 8b/-> *(ebp+0xc) 6/r32/esi
18617
18618 8d/copy-address *(esi+4) 0/r32/eax
18619 (append-list *(ebp+8) *(ebp+0x10) *(ebp+0x14) *(esi+4) *(esi+8) %eax)
18620 $append-to-block:end:
18621
18622 5e/pop-to-esi
18623 58/pop-to-eax
18624
18625 89/<- %esp 5/r32/ebp
18626 5d/pop-to-ebp
18627 c3/return
18628
18629
18630
18631
18632
18633
18634
18635 lookup-or-create-constant:
18636
18637 55/push-ebp
18638 89/<- %ebp 4/r32/esp
18639
18640 50/push-eax
18641 56/push-esi
18642
18643 (container-type *(ebp+8))
18644 89/<- %esi 0/r32/eax
18645
18646 68/push 0/imm32
18647 68/push 0/imm32
18648 89/<- %eax 4/r32/esp
18649 (find-or-create-typeinfo %esi %eax)
18650
18651 (lookup *eax *(eax+4))
18652
18653
18654
18655
18656
18657 (find-or-create-typeinfo-output-var %eax *(ebp+0xc) *(ebp+0x10))
18658
18659
18660
18661
18662
18663
18664
18665
18666
18667
18668
18669
18670
18671 $lookup-or-create-constant:end:
18672
18673 81 0/subop/add %esp 8/imm32
18674
18675 5e/pop-to-esi
18676 58/pop-to-eax
18677
18678 89/<- %esp 5/r32/ebp
18679 5d/pop-to-ebp
18680 c3/return
18681
18682
18683
18684
18685
18686 container-type:
18687
18688 55/push-ebp
18689 89/<- %ebp 4/r32/esp
18690
18691 8b/-> *(ebp+8) 0/r32/eax
18692 (lookup *eax *(eax+4))
18693 (lookup *(eax+8) *(eax+0xc))
18694 {
18695 81 7/subop/compare *(eax+8) 0/imm32
18696 74/jump-if-= break/disp8
18697 (lookup *(eax+0xc) *(eax+0x10))
18698 (lookup *(eax+4) *(eax+8))
18699 }
18700 8b/-> *(eax+4) 0/r32/eax
18701 $container-type:end:
18702
18703 89/<- %esp 5/r32/ebp
18704 5d/pop-to-ebp
18705 c3/return
18706
18707 is-container?:
18708
18709 55/push-ebp
18710 89/<- %ebp 4/r32/esp
18711
18712 8b/-> *(ebp+8) 0/r32/eax
18713 c1/shift 4/subop/left %eax 2/imm8
18714 3b/compare 0/r32/eax *Primitive-type-ids
18715 0f 9d/set-if->= %al
18716 81 4/subop/and %eax 0xff/imm32
18717 $is-container?:end:
18718
18719 89/<- %esp 5/r32/ebp
18720 5d/pop-to-ebp
18721 c3/return
18722
18723 find-or-create-typeinfo:
18724
18725 55/push-ebp
18726 89/<- %ebp 4/r32/esp
18727
18728 50/push-eax
18729 51/push-ecx
18730 52/push-edx
18731 57/push-edi
18732
18733 8b/-> *(ebp+0xc) 7/r32/edi
18734
18735 68/push 0/imm32
18736 68/push 0/imm32
18737 89/<- %ecx 4/r32/esp
18738
18739 (find-typeinfo *(ebp+8) %edi)
18740 {
18741
18742 81 7/subop/compare *edi 0/imm32
18743 0f 85/jump-if-!= break/disp32
18744 $find-or-create-typeinfo:create:
18745
18746 (allocate Heap *Typeinfo-size %edi)
18747
18748 (lookup *edi *(edi+4))
18749
18750
18751
18752
18753
18754
18755
18756 8b/-> *(ebp+8) 2/r32/edx
18757 89/<- *eax 2/r32/edx
18758
18759
18760 (new-stream Heap 0x40 *Typeinfo-fields-row-size %ecx)
18761
18762 8b/-> *ecx 2/r32/edx
18763 89/<- *(eax+4) 2/r32/edx
18764 8b/-> *(ecx+4) 2/r32/edx
18765 89/<- *(eax+8) 2/r32/edx
18766
18767 8b/-> *_Program-types 1/r32/ecx
18768 89/<- *(eax+0x10) 1/r32/ecx
18769 8b/-> *_Program-types->payload 1/r32/ecx
18770 89/<- *(eax+0x14) 1/r32/ecx
18771
18772 8b/-> *edi 1/r32/ecx
18773 89/<- *_Program-types 1/r32/ecx
18774 8b/-> *(edi+4) 1/r32/ecx
18775 89/<- *_Program-types->payload 1/r32/ecx
18776 }
18777 $find-or-create-typeinfo:end:
18778
18779 81 0/subop/add %esp 8/imm32
18780
18781 5f/pop-to-edi
18782 5a/pop-to-edx
18783 59/pop-to-ecx
18784 58/pop-to-eax
18785
18786 89/<- %esp 5/r32/ebp
18787 5d/pop-to-ebp
18788 c3/return
18789
18790 find-typeinfo:
18791
18792 55/push-ebp
18793 89/<- %ebp 4/r32/esp
18794
18795 50/push-eax
18796 51/push-ecx
18797 52/push-edx
18798 57/push-edi
18799
18800 8b/-> *(ebp+8) 1/r32/ecx
18801
18802 8b/-> *(ebp+0xc) 7/r32/edi
18803
18804 8b/-> *_Program-types 0/r32/eax
18805 89/<- *edi 0/r32/eax
18806 8b/-> *_Program-types->payload 0/r32/eax
18807 89/<- *(edi+4) 0/r32/eax
18808 {
18809 $find-typeinfo:loop:
18810
18811 81 7/subop/compare *edi 0/imm32
18812 74/jump-if-= break/disp8
18813 $find-typeinfo:check:
18814
18815 (lookup *edi *(edi+4))
18816
18817 39/compare *eax 1/r32/ecx
18818 74/jump-if-= break/disp8
18819 $find-typeinfo:continue:
18820
18821 8b/-> *(eax+0x10) 2/r32/edx
18822 89/<- *edi 2/r32/edx
18823 8b/-> *(eax+0x14) 2/r32/edx
18824 89/<- *(edi+4) 2/r32/edx
18825
18826 eb/jump loop/disp8
18827 }
18828 $find-typeinfo:end:
18829
18830 5f/pop-to-edi
18831 5a/pop-to-edx
18832 59/pop-to-ecx
18833 58/pop-to-eax
18834
18835 89/<- %esp 5/r32/ebp
18836 5d/pop-to-ebp
18837 c3/return
18838
18839 find-or-create-typeinfo-output-var:
18840
18841 55/push-ebp
18842 89/<- %ebp 4/r32/esp
18843
18844 50/push-eax
18845 52/push-edx
18846 57/push-edi
18847
18848 68/push 0/imm32
18849 68/push 0/imm32
18850 89/<- %edi 4/r32/esp
18851
18852 (find-or-create-typeinfo-fields *(ebp+8) *(ebp+0xc) %edi)
18853
18854 (lookup *edi *(edi+4))
18855 89/<- %edi 0/r32/eax
18856
18857 {
18858 81 7/subop/compare *(edi+0xc) 0/imm32
18859 0f 85/jump-if-!= break/disp32
18860
18861
18862 68/push 0/imm32
18863 68/push 0/imm32
18864 89/<- %eax 4/r32/esp
18865 (slice-to-string Heap *(ebp+0xc) %eax)
18866
18867 8d/copy-address *(edi+0xc) 2/r32/edx
18868 (new-var Heap *eax *(eax+4) %edx)
18869
18870 81 0/subop/add %esp 8/imm32
18871
18872 (lookup *(edi+0xc) *(edi+0x10))
18873 89/<- %edx 0/r32/eax
18874
18875 8d/copy-address *(edx+8) 0/r32/eax
18876 (allocate Heap *Type-tree-size %eax)
18877 (lookup *(edx+8) *(edx+0xc))
18878 c7 0/subop/copy *eax 1/imm32/true
18879 c7 0/subop/copy *(eax+4) 6/imm32/constant
18880 c7 0/subop/copy *(eax+8) 0/imm32
18881 c7 0/subop/copy *(eax+0xc) 0/imm32
18882 c7 0/subop/copy *(eax+0x10) 0/imm32
18883
18884 c7 0/subop/copy *(edx+0x14) -1/imm32/uninitialized
18885 }
18886
18887 8b/-> *(ebp+0x10) 2/r32/edx
18888 8b/-> *(edi+0xc) 0/r32/eax
18889 89/<- *edx 0/r32/eax
18890 8b/-> *(edi+0x10) 0/r32/eax
18891 89/<- *(edx+4) 0/r32/eax
18892 $find-or-create-typeinfo-output-var:end:
18893
18894 81 0/subop/add %esp 8/imm32
18895
18896 5f/pop-to-edi
18897 5a/pop-to-edx
18898 58/pop-to-eax
18899
18900 89/<- %esp 5/r32/ebp
18901 5d/pop-to-ebp
18902 c3/return
18903
18904 find-or-create-typeinfo-fields:
18905
18906 55/push-ebp
18907 89/<- %ebp 4/r32/esp
18908
18909 50/push-eax
18910 56/push-esi
18911 57/push-edi
18912
18913 8b/-> *(ebp+8) 0/r32/eax
18914 (lookup *(eax+4) *(eax+8))
18915
18916 8b/-> *(ebp+0x10) 7/r32/edi
18917
18918 (get-or-insert-slice %eax *(ebp+0xc) *Typeinfo-fields-row-size Heap)
18919 89/<- %esi 0/r32/eax
18920
18921 {
18922 81 7/subop/compare *esi 0/imm32
18923 75/jump-if-!= break/disp8
18924 (allocate Heap *Typeinfo-entry-size %esi)
18925
18926
18927
18928
18929
18930
18931
18932
18933
18934
18935
18936
18937
18938
18939
18940 }
18941
18942
18943 8b/-> *esi 0/r32/eax
18944 89/<- *edi 0/r32/eax
18945 8b/-> *(esi+4) 0/r32/eax
18946 89/<- *(edi+4) 0/r32/eax
18947 $find-or-create-typeinfo-fields:end:
18948
18949 5f/pop-to-edi
18950 5e/pop-to-esi
18951 58/pop-to-eax
18952
18953 89/<- %esp 5/r32/ebp
18954 5d/pop-to-ebp
18955 c3/return
18956
18957 populate-mu-type:
18958
18959
18960
18961
18962
18963
18964
18965
18966
18967
18968
18969
18970
18971
18972
18973
18974
18975
18976
18977
18978
18979
18980
18981
18982
18983 55/push-ebp
18984 89/<- %ebp 4/r32/esp
18985
18986 68/push 0/imm32
18987
18988 50/push-eax
18989 51/push-ecx
18990 52/push-edx
18991 53/push-ebx
18992 56/push-esi
18993 57/push-edi
18994
18995 8b/-> *(ebp+0xc) 7/r32/edi
18996
18997 81 5/subop/subtract %esp 0x200/imm32
18998 68/push 0x200/imm32/size
18999 68/push 0/imm32/read
19000 68/push 0/imm32/write
19001 89/<- %ecx 4/r32/esp
19002
19003 68/push 0/imm32/end
19004 68/push 0/imm32/start
19005 89/<- %edx 4/r32/esp
19006
19007 68/push 0/imm32
19008 68/push 0/imm32
19009 89/<- %esi 4/r32/esp
19010
19011 68/push 0/imm32
19012 68/push 0/imm32
19013 89/<- %ebx 4/r32/esp
19014 {
19015 $populate-mu-type:line-loop:
19016 (clear-stream %ecx)
19017 (read-line-buffered *(ebp+8) %ecx)
19018
19019 81 7/subop/compare *ecx 0/imm32
19020 0f 84/jump-if-= $populate-mu-type:error1/disp32
19021 +-- 6 lines: #? # dump line ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
19027 (next-mu-token %ecx %edx)
19028
19029 (slice-empty? %edx)
19030 3d/compare-eax-and 0/imm32
19031 0f 85/jump-if-!= loop/disp32
19032
19033 (slice-equal? %edx "}")
19034 3d/compare-eax-and 0/imm32
19035 0f 85/jump-if-!= break/disp32
19036 $populate-mu-type:parse-element:
19037
19038
19039
19040
19041 (type-name *edi)
19042 (parse-var-with-type %edx %ecx %esi %eax *(ebp+0x10) *(ebp+0x14))
19043
19044 (lookup *esi *(esi+4))
19045 (lookup *(eax+8) *(eax+0xc))
19046 (is-mu-addr-type? %eax)
19047 3d/compare-eax-and 0/imm32/false
19048 0f 85/jump-if-!= $populate-mu-type:error2/disp32
19049
19050 (lookup *esi *(esi+4))
19051 (lookup *(eax+8) *(eax+0xc))
19052 (is-mu-array-type? %eax)
19053 3d/compare-eax-and 0/imm32/false
19054 0f 85/jump-if-!= $populate-mu-type:error3/disp32
19055
19056 (lookup *esi *(esi+4))
19057 (lookup *(eax+8) *(eax+0xc))
19058 (is-simple-mu-type? %eax 8)
19059 3d/compare-eax-and 0/imm32/false
19060 0f 85/jump-if-!= $populate-mu-type:error4/disp32
19061
19062 (lookup *esi *(esi+4))
19063 (lookup *(eax+8) *(eax+0xc))
19064 (is-simple-mu-type? %eax 0xc)
19065 3d/compare-eax-and 0/imm32/false
19066 0f 85/jump-if-!= $populate-mu-type:error5/disp32
19067
19068 (lookup *esi *(esi+4))
19069 (lookup *(eax+8) *(eax+0xc))
19070 (is-mu-stream-type? %eax)
19071 3d/compare-eax-and 0/imm32/false
19072 0f 85/jump-if-!= $populate-mu-type:error6/disp32
19073
19074 51/push-ecx
19075 $populate-mu-type:create-typeinfo-fields:
19076
19077 (find-or-create-typeinfo-fields %edi %edx %ebx)
19078
19079 (lookup *ebx *(ebx+4))
19080 8b/-> *(ebp-4) 1/r32/ecx
19081
19082
19083
19084
19085
19086
19087 89/<- *(eax+8) 1/r32/ecx
19088
19089 ff 0/subop/increment *(ebp-4)
19090 $populate-mu-type:set-input-type:
19091
19092 8b/-> *esi 1/r32/ecx
19093 89/<- *eax 1/r32/ecx
19094 8b/-> *(esi+4) 1/r32/ecx
19095 89/<- *(eax+4) 1/r32/ecx
19096
19097 59/pop-to-ecx
19098 {
19099 $populate-mu-type:create-output-type:
19100
19101 81 7/subop/compare *(eax+0xc) 0/imm32
19102 75/jump-if-!= break/disp8
19103 8d/copy-address *(eax+0xc) 0/r32/eax
19104 (new-literal Heap %edx %eax)
19105 }
19106 e9/jump loop/disp32
19107 }
19108 $populate-mu-type:invalidate-total-size-in-bytes:
19109
19110
19111
19112 c7 0/subop/copy *(edi+0xc) -2/imm32/uninitialized
19113 $populate-mu-type:end:
19114
19115 81 0/subop/add %esp 0x224/imm32
19116
19117 5f/pop-to-edi
19118 5e/pop-to-esi
19119 5b/pop-to-ebx
19120 5a/pop-to-edx
19121 59/pop-to-ecx
19122 58/pop-to-eax
19123
19124 81 0/subop/add %esp 4/imm32
19125
19126 89/<- %esp 5/r32/ebp
19127 5d/pop-to-ebp
19128 c3/return
19129
19130 $populate-mu-type:error1:
19131
19132 (write-buffered *(ebp+0x10) "incomplete type definition '")
19133 (type-name *edi)
19134 (write-buffered *(ebp+0x10) %eax)
19135 (write-buffered *(ebp+0x10) "\n")
19136 (flush *(ebp+0x10))
19137 (stop *(ebp+0x14) 1)
19138
19139
19140 $populate-mu-type:error2:
19141 (write-buffered *(ebp+0x10) "type ")
19142 (type-name *edi)
19143 (write-buffered *(ebp+0x10) %eax)
19144 (write-buffered *(ebp+0x10) ": 'addr' elements not allowed\n")
19145 (flush *(ebp+0x10))
19146 (stop *(ebp+0x14) 1)
19147
19148
19149 $populate-mu-type:error3:
19150 (write-buffered *(ebp+0x10) "type ")
19151 (type-name *edi)
19152 (write-buffered *(ebp+0x10) %eax)
19153 (write-buffered *(ebp+0x10) ": 'array' elements not allowed for now\n")
19154 (flush *(ebp+0x10))
19155 (stop *(ebp+0x14) 1)
19156
19157
19158 $populate-mu-type:error4:
19159 (write-buffered *(ebp+0x10) "type ")
19160 (type-name *edi)
19161 (write-buffered *(ebp+0x10) %eax)
19162 (write-buffered *(ebp+0x10) ": 'byte' elements not allowed\n")
19163 (flush *(ebp+0x10))
19164 (stop *(ebp+0x14) 1)
19165
19166
19167 $populate-mu-type:error5:
19168 (write-buffered *(ebp+0x10) "type ")
19169 (type-name *edi)
19170 (write-buffered *(ebp+0x10) %eax)
19171 (write-buffered *(ebp+0x10) ": 'slice' elements not allowed\n")
19172 (flush *(ebp+0x10))
19173 (stop *(ebp+0x14) 1)
19174
19175
19176 $populate-mu-type:error6:
19177 (write-buffered *(ebp+0x10) "type ")
19178 (type-name *edi)
19179 (write-buffered *(ebp+0x10) %eax)
19180 (write-buffered *(ebp+0x10) ": 'stream' elements not allowed for now\n")
19181 (flush *(ebp+0x10))
19182 (stop *(ebp+0x14) 1)
19183
19184
19185 type-name:
19186
19187 55/push-ebp
19188 89/<- %ebp 4/r32/esp
19189
19190 (index Type-id *(ebp+8))
19191 $type-name:end:
19192
19193 89/<- %esp 5/r32/ebp
19194 5d/pop-to-ebp
19195 c3/return
19196
19197 index:
19198
19199 55/push-ebp
19200 89/<- %ebp 4/r32/esp
19201
19202 56/push-esi
19203
19204
19205 8b/-> *(ebp+8) 6/r32/esi
19206
19207 8b/-> *(ebp+0xc) 0/r32/eax
19208
19209 8b/-> *(esi+eax<<2+0xc) 0/r32/eax
19210 $index:end:
19211
19212 5e/pop-to-esi
19213
19214 89/<- %esp 5/r32/ebp
19215 5d/pop-to-ebp
19216 c3/return
19217
19218
19219
19220
19221
19222
19223
19224
19225
19226
19227 populate-mu-type-sizes:
19228
19229 55/push-ebp
19230 89/<- %ebp 4/r32/esp
19231 $populate-mu-type-sizes:total-sizes:
19232
19233 (lookup *_Program-types *_Program-types->payload)
19234 {
19235
19236 3d/compare-eax-and 0/imm32/null
19237 74/jump-if-= break/disp8
19238 (populate-mu-type-sizes-in-type %eax *(ebp+8) *(ebp+0xc))
19239
19240 (lookup *(eax+0x10) *(eax+0x14))
19241 eb/jump loop/disp8
19242 }
19243 $populate-mu-type-sizes:offsets:
19244
19245 (lookup *_Program-types *_Program-types->payload)
19246 {
19247
19248 3d/compare-eax-and 0/imm32/null
19249 74/jump-if-= break/disp8
19250 (populate-mu-type-offsets %eax *(ebp+8) *(ebp+0xc))
19251
19252 (lookup *(eax+0x10) *(eax+0x14))
19253 eb/jump loop/disp8
19254 }
19255 $populate-mu-type-sizes:end:
19256
19257 89/<- %esp 5/r32/ebp
19258 5d/pop-to-ebp
19259 c3/return
19260
19261
19262
19263
19264 populate-mu-type-sizes-in-type:
19265
19266 55/push-ebp
19267 89/<- %ebp 4/r32/esp
19268
19269 50/push-eax
19270 51/push-ecx
19271 52/push-edx
19272 56/push-esi
19273 57/push-edi
19274
19275 8b/-> *(ebp+8) 6/r32/esi
19276
19277 81 7/subop/compare *(esi+0xc) 0/imm32
19278 0f 8d/jump-if->= $populate-mu-type-sizes-in-type:end/disp32
19279
19280 81 7/subop/compare *(esi+0xc) -1/imm32/being-computed
19281 0f 84/jump-if-= $populate-mu-type-sizes-in-type:abort/disp32
19282
19283 c7 0/subop/copy *(esi+0xc) -1/imm32/being-computed
19284
19285 bf/copy-to-edi 0/imm32
19286
19287
19288 (lookup *(esi+4) *(esi+8))
19289 89/<- %ecx 0/r32/eax
19290
19291 8b/-> *ecx 2/r32/edx
19292
19293 8d/copy-address *(ecx+0xc) 1/r32/ecx
19294
19295 8d/copy-address *(ecx+edx) 2/r32/edx
19296 {
19297 $populate-mu-type-sizes-in-type:loop:
19298
19299 39/compare %ecx 2/r32/edx
19300 73/jump-if-addr>= break/disp8
19301
19302 (lookup *(ecx+8) *(ecx+0xc))
19303
19304 81 7/subop/compare *eax 0/imm32
19305 74/jump-if-= $populate-mu-type-sizes-in-type:end/disp8
19306
19307 (lookup *eax *(eax+4))
19308 (compute-size-of-var %eax *(ebp+0xc) *(ebp+0x10))
19309
19310 01/add-to %edi 0/r32/eax
19311
19312 81 0/subop/add %ecx 0x10/imm32
19313
19314 eb/jump loop/disp8
19315 }
19316
19317 89/<- *(esi+0xc) 7/r32/edi
19318 $populate-mu-type-sizes-in-type:end:
19319
19320 5f/pop-to-edi
19321 5e/pop-to-esi
19322 5a/pop-to-edx
19323 59/pop-to-ecx
19324 58/pop-to-eax
19325
19326 89/<- %esp 5/r32/ebp
19327 5d/pop-to-ebp
19328 c3/return
19329
19330 $populate-mu-type-sizes-in-type:abort:
19331 (write-buffered *(ebp+0xc) "cycle in type definitions\n")
19332 (flush *(ebp+0xc))
19333 (stop *(ebp+0x10) 1)
19334
19335
19336
19337
19338 compute-size-of-var:
19339
19340 55/push-ebp
19341 89/<- %ebp 4/r32/esp
19342
19343 51/push-ecx
19344
19345 8b/-> *(ebp+8) 1/r32/ecx
19346 (lookup *(ecx+8) *(ecx+0xc))
19347 89/<- %ecx 0/r32/eax
19348
19349 {
19350 81 7/subop/compare *ecx 0/imm32/false
19351 75/jump-if-!= break/disp8
19352 (lookup *(ecx+4) *(ecx+8))
19353 89/<- %ecx 0/r32/eax
19354 }
19355
19356 (compute-size-of-type-id *(ecx+4) *(ebp+0xc) *(ebp+0x10))
19357 $compute-size-of-var:end:
19358
19359 59/pop-to-ecx
19360
19361 89/<- %esp 5/r32/ebp
19362 5d/pop-to-ebp
19363 c3/return
19364
19365 compute-size-of-type-id:
19366
19367 55/push-ebp
19368 89/<- %ebp 4/r32/esp
19369
19370 51/push-ecx
19371
19372 68/push 0/imm32
19373 68/push 0/imm32
19374 89/<- %ecx 4/r32/esp
19375
19376 8b/-> *(ebp+8) 0/r32/eax
19377
19378 3d/compare-eax-and 0/imm32/literal
19379 0f 84/jump-if-= $compute-size-of-type-id:end/disp32
19380
19381 3d/compare-eax-and 8/imm32/byte
19382 {
19383 75/jump-if-!= break/disp8
19384 b8/copy-to-eax 4/imm32
19385 eb/jump $compute-size-of-type-id:end/disp8
19386 }
19387
19388 3d/compare-eax-and 4/imm32/handle
19389 {
19390 75/jump-if-!= break/disp8
19391 b8/copy-to-eax 8/imm32
19392 eb/jump $compute-size-of-type-id:end/disp8
19393 }
19394
19395 3d/compare-eax-and 0xc/imm32/slice
19396 {
19397 75/jump-if-!= break/disp8
19398 b8/copy-to-eax 8/imm32
19399 eb/jump $compute-size-of-type-id:end/disp8
19400 }
19401
19402
19403 (find-typeinfo %eax %ecx)
19404 {
19405 81 7/subop/compare *ecx 0/imm32
19406 74/jump-if-= break/disp8
19407 $compute-size-of-type-id:user-defined:
19408 (lookup *ecx *(ecx+4))
19409 (populate-mu-type-sizes-in-type %eax *(ebp+0xc) *(ebp+0x10))
19410 8b/-> *(eax+0xc) 0/r32/eax
19411 eb/jump $compute-size-of-type-id:end/disp8
19412 }
19413
19414 b8/copy-to-eax 4/imm32
19415 $compute-size-of-type-id:end:
19416
19417 81 0/subop/add %esp 8/imm32
19418
19419 59/pop-to-ecx
19420
19421 89/<- %esp 5/r32/ebp
19422 5d/pop-to-ebp
19423 c3/return
19424
19425
19426
19427
19428 populate-mu-type-offsets:
19429
19430 55/push-ebp
19431 89/<- %ebp 4/r32/esp
19432
19433 50/push-eax
19434 51/push-ecx
19435 52/push-edx
19436 53/push-ebx
19437 56/push-esi
19438 57/push-edi
19439
19440
19441 bf/copy-to-edi 0/imm32
19442
19443 8b/-> *(ebp+8) 1/r32/ecx
19444 (lookup *(ecx+4) *(ecx+8))
19445 89/<- %ecx 0/r32/eax
19446
19447 8b/-> *ecx 2/r32/edx
19448 c1 5/subop/shift-right-logical %edx 4/imm8
19449
19450 bb/copy-to-ebx 0/imm32
19451 {
19452 $populate-mu-type-offsets:loop:
19453 39/compare %ebx 2/r32/edx
19454 0f 8d/jump-if->= break/disp32
19455
19456
19457
19458
19459
19460
19461
19462 (locate-typeinfo-entry-with-index %ecx %ebx *(ebp+0xc) *(ebp+0x10))
19463 89/<- %esi 0/r32/eax
19464
19465 81 7/subop/compare %esi 0/imm32
19466 74/jump-if-= $populate-mu-type-offsets:end/disp8
19467
19468 81 7/subop/compare *esi 0/imm32
19469 74/jump-if-= $populate-mu-type-offsets:end/disp8
19470
19471
19472 (lookup *(esi+0xc) *(esi+0x10))
19473 89/<- *(eax+0x14) 7/r32/edi
19474
19475 (lookup *esi *(esi+4))
19476 (size-of %eax)
19477 01/add-to %edi 0/r32/eax
19478
19479 43/increment-ebx
19480 e9/jump loop/disp32
19481 }
19482 $populate-mu-type-offsets:end:
19483
19484 5f/pop-to-edi
19485 5e/pop-to-esi
19486 5b/pop-to-ebx
19487 5a/pop-to-edx
19488 59/pop-to-ecx
19489 58/pop-to-eax
19490
19491 89/<- %esp 5/r32/ebp
19492 5d/pop-to-ebp
19493 c3/return
19494
19495 locate-typeinfo-entry-with-index:
19496
19497 55/push-ebp
19498 89/<- %ebp 4/r32/esp
19499
19500 51/push-ecx
19501 52/push-edx
19502 53/push-ebx
19503 56/push-esi
19504 57/push-edi
19505
19506 8b/-> *(ebp+8) 6/r32/esi
19507
19508 8d/copy-address *(esi+0xc) 1/r32/ecx
19509
19510 8b/-> *esi 2/r32/edx
19511 8d/copy-address *(ecx+edx) 2/r32/edx
19512 {
19513 $locate-typeinfo-entry-with-index:loop:
19514 39/compare %ecx 2/r32/edx
19515 73/jump-if-addr>= break/disp8
19516
19517 (lookup *(ecx+8) *(ecx+0xc))
19518
19519 8b/-> *(eax+8) 3/r32/ebx
19520
19521
19522
19523
19524
19525
19526 39/compare *(ebp+0xc) 3/r32/ebx
19527 74/jump-if-= $locate-typeinfo-entry-with-index:end/disp8
19528
19529 81 0/subop/add %ecx 0x10/imm32
19530
19531 eb/jump loop/disp8
19532 }
19533
19534 b8/copy-to-eax 0/imm32
19535 $locate-typeinfo-entry-with-index:end:
19536
19537
19538
19539
19540
19541 5f/pop-to-edi
19542 5e/pop-to-esi
19543 5b/pop-to-ebx
19544 5a/pop-to-edx
19545 59/pop-to-ecx
19546
19547 89/<- %esp 5/r32/ebp
19548 5d/pop-to-ebp
19549 c3/return
19550
19551 dump-typeinfos:
19552
19553 55/push-ebp
19554 89/<- %ebp 4/r32/esp
19555
19556 50/push-eax
19557
19558 (write-buffered Stderr *(ebp+8))
19559 (flush Stderr)
19560
19561 (lookup *_Program-types *_Program-types->payload)
19562 {
19563
19564 3d/compare-eax-and 0/imm32
19565 74/jump-if-= break/disp8
19566 (write-buffered Stderr "---\n")
19567 (flush Stderr)
19568 (dump-typeinfo %eax)
19569
19570 (lookup *(eax+0x10) *(eax+0x14))
19571 eb/jump loop/disp8
19572 }
19573 $dump-typeinfos:end:
19574
19575 58/pop-to-eax
19576
19577 89/<- %esp 5/r32/ebp
19578 5d/pop-to-ebp
19579 c3/return
19580
19581 dump-typeinfo:
19582
19583 55/push-ebp
19584 89/<- %ebp 4/r32/esp
19585
19586 50/push-eax
19587 51/push-ecx
19588 52/push-edx
19589 53/push-ebx
19590 56/push-esi
19591 57/push-edi
19592
19593 8b/-> *(ebp+8) 6/r32/esi
19594
19595 (lookup *(esi+4) *(esi+8))
19596 89/<- %ecx 0/r32/eax
19597 (write-buffered Stderr "id:")
19598 (write-int32-hex-buffered Stderr *esi)
19599 (write-buffered Stderr "\n")
19600 (write-buffered Stderr "fields @ ")
19601 (write-int32-hex-buffered Stderr %ecx)
19602 (write-buffered Stderr Newline)
19603 (flush Stderr)
19604 (write-buffered Stderr " write: ")
19605 (write-int32-hex-buffered Stderr *ecx)
19606 (write-buffered Stderr Newline)
19607 (flush Stderr)
19608 (write-buffered Stderr " read: ")
19609 (write-int32-hex-buffered Stderr *(ecx+4))
19610 (write-buffered Stderr Newline)
19611 (flush Stderr)
19612 (write-buffered Stderr " size: ")
19613 (write-int32-hex-buffered Stderr *(ecx+8))
19614 (write-buffered Stderr Newline)
19615 (flush Stderr)
19616
19617 8b/-> *ecx 2/r32/edx
19618
19619 8d/copy-address *(ecx+0xc) 1/r32/ecx
19620
19621 8d/copy-address *(ecx+edx) 2/r32/edx
19622 {
19623 $dump-typeinfo:loop:
19624
19625 39/compare %ecx 2/r32/edx
19626 0f 83/jump-if-addr>= break/disp32
19627 (write-buffered Stderr " row:\n")
19628 (write-buffered Stderr " key: ")
19629 (write-int32-hex-buffered Stderr *ecx)
19630 (write-buffered Stderr ",")
19631 (write-int32-hex-buffered Stderr *(ecx+4))
19632 (write-buffered Stderr " = '")
19633 (lookup *ecx *(ecx+4))
19634 (write-buffered Stderr %eax)
19635 (write-buffered Stderr "' @ ")
19636 (write-int32-hex-buffered Stderr %eax)
19637 (write-buffered Stderr Newline)
19638 (flush Stderr)
19639 (write-buffered Stderr " value: ")
19640 (write-int32-hex-buffered Stderr *(ecx+8))
19641 (write-buffered Stderr ",")
19642 (write-int32-hex-buffered Stderr *(ecx+0xc))
19643 (write-buffered Stderr " = typeinfo-entry@")
19644 (lookup *(ecx+8) *(ecx+0xc))
19645 (write-int32-hex-buffered Stderr %eax)
19646 (write-buffered Stderr Newline)
19647 (flush Stderr)
19648 (write-buffered Stderr " input var@")
19649 (dump-var 5 %eax)
19650 (lookup *(ecx+8) *(ecx+0xc))
19651 (write-buffered Stderr " index: ")
19652 (write-int32-hex-buffered Stderr *(eax+8))
19653 (write-buffered Stderr Newline)
19654 (flush Stderr)
19655 (write-buffered Stderr " output var@")
19656 8d/copy-address *(eax+0xc) 0/r32/eax
19657 (dump-var 5 %eax)
19658 (flush Stderr)
19659
19660 81 0/subop/add %ecx 0x10/imm32
19661
19662 e9/jump loop/disp32
19663 }
19664 $dump-typeinfo:end:
19665
19666 5f/pop-to-edi
19667 5e/pop-to-esi
19668 5b/pop-to-ebx
19669 5a/pop-to-edx
19670 59/pop-to-ecx
19671 58/pop-to-eax
19672
19673 89/<- %esp 5/r32/ebp
19674 5d/pop-to-ebp
19675 c3/return
19676
19677 dump-var:
19678
19679 55/push-ebp
19680 89/<- %ebp 4/r32/esp
19681
19682 50/push-eax
19683 53/push-ebx
19684
19685 8b/-> *(ebp+0xc) 0/r32/eax
19686
19687 (write-int32-hex-buffered Stderr *eax)
19688 (write-buffered Stderr ",")
19689 (write-int32-hex-buffered Stderr *(eax+4))
19690 (write-buffered Stderr "->")
19691 (lookup *eax *(eax+4))
19692 (write-int32-hex-buffered Stderr %eax)
19693 (write-buffered Stderr Newline)
19694 (flush Stderr)
19695 {
19696 3d/compare-eax-and 0/imm32
19697 0f 84/jump-if-= break/disp32
19698 (emit-indent Stderr *(ebp+8))
19699 (write-buffered Stderr "name: ")
19700 89/<- %ebx 0/r32/eax
19701 (write-int32-hex-buffered Stderr *ebx)
19702 (write-buffered Stderr ",")
19703 (write-int32-hex-buffered Stderr *(ebx+4))
19704 (write-buffered Stderr "->")
19705 (lookup *ebx *(ebx+4))
19706 (write-int32-hex-buffered Stderr %eax)
19707 {
19708 3d/compare-eax-and 0/imm32
19709 74/jump-if-= break/disp8
19710 (write-buffered Stderr Space)
19711 (write-buffered Stderr %eax)
19712 }
19713 (write-buffered Stderr Newline)
19714 (flush Stderr)
19715 (emit-indent Stderr *(ebp+8))
19716 (write-buffered Stderr "block depth: ")
19717 (write-int32-hex-buffered Stderr *(ebx+0x10))
19718 (write-buffered Stderr Newline)
19719 (flush Stderr)
19720 (emit-indent Stderr *(ebp+8))
19721 (write-buffered Stderr "stack offset: ")
19722 (write-int32-hex-buffered Stderr *(ebx+0x14))
19723 (write-buffered Stderr Newline)
19724 (flush Stderr)
19725 (emit-indent Stderr *(ebp+8))
19726 (write-buffered Stderr "reg: ")
19727 (write-int32-hex-buffered Stderr *(ebx+0x18))
19728 (write-buffered Stderr ",")
19729 (write-int32-hex-buffered Stderr *(ebx+0x1c))
19730 (write-buffered Stderr "->")
19731 (flush Stderr)
19732 (lookup *(ebx+0x18) *(ebx+0x1c))
19733 (write-int32-hex-buffered Stderr %eax)
19734 {
19735 3d/compare-eax-and 0/imm32
19736 74/jump-if-= break/disp8
19737 (write-buffered Stderr Space)
19738 (write-buffered Stderr %eax)
19739 }
19740 (write-buffered Stderr Newline)
19741 (flush Stderr)
19742 }
19743 $dump-var:end:
19744
19745 5b/pop-to-ebx
19746 58/pop-to-eax
19747
19748 89/<- %esp 5/r32/ebp
19749 5d/pop-to-ebp
19750 c3/return
19751
19752
19753
19754
19755
19756 check-mu-types:
19757
19758 55/push-ebp
19759 89/<- %ebp 4/r32/esp
19760
19761 50/push-eax
19762
19763 (lookup *_Program-functions *_Program-functions->payload)
19764 {
19765 $check-mu-types:loop:
19766
19767 3d/compare-eax-and 0/imm32
19768 0f 84/jump-if-= break/disp32
19769 +-- 8 lines: #? # dump curr->name ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
19777 (check-mu-function %eax *(ebp+8) *(ebp+0xc))
19778
19779 (lookup *(eax+0x20) *(eax+0x24))
19780 e9/jump loop/disp32
19781 }
19782 $check-mu-types:end:
19783
19784 58/pop-to-eax
19785
19786 89/<- %esp 5/r32/ebp
19787 5d/pop-to-ebp
19788 c3/return
19789
19790 check-mu-function:
19791
19792 55/push-ebp
19793 89/<- %ebp 4/r32/esp
19794
19795 50/push-eax
19796 56/push-esi
19797
19798 8b/-> *(ebp+8) 6/r32/esi
19799
19800 (lookup *(esi+0x10) *(esi+0x14))
19801 (check-all-unique-registers %eax %esi *(ebp+0xc) *(ebp+0x10))
19802
19803 (lookup *(esi+0x18) *(esi+0x1c))
19804 (check-mu-block %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10))
19805
19806 81 7/subop/compare *(esi+0x10) 0/imm32
19807 74/jump-if-= $check-mu-function:end/disp8
19808
19809 (check-final-stmt-is-return %eax %esi *(ebp+0xc) *(ebp+0x10))
19810 (check-no-breaks %eax %esi *(ebp+0xc) *(ebp+0x10))
19811 $check-mu-function:end:
19812
19813 5e/pop-to-esi
19814 58/pop-to-eax
19815
19816 89/<- %esp 5/r32/ebp
19817 5d/pop-to-ebp
19818 c3/return
19819
19820 check-mu-block:
19821
19822 55/push-ebp
19823 89/<- %ebp 4/r32/esp
19824
19825 50/push-eax
19826
19827 8b/-> *(ebp+8) 0/r32/eax
19828
19829 (lookup *(eax+4) *(eax+8))
19830
19831 {
19832 $check-mu-block:check-empty:
19833 3d/compare-eax-and 0/imm32
19834 0f 84/jump-if-= break/disp32
19835
19836 (check-mu-stmt-list %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
19837 }
19838 $check-mu-block:end:
19839
19840 58/pop-to-eax
19841
19842 89/<- %esp 5/r32/ebp
19843 5d/pop-to-ebp
19844 c3/return
19845
19846 check-mu-stmt-list:
19847
19848 55/push-ebp
19849 89/<- %ebp 4/r32/esp
19850
19851 50/push-eax
19852 56/push-esi
19853
19854 8b/-> *(ebp+8) 6/r32/esi
19855 {
19856 $check-mu-stmt-list:loop:
19857 81 7/subop/compare %esi 0/imm32
19858 0f 84/jump-if-= break/disp32
19859
19860 (lookup *esi *(esi+4))
19861 {
19862 $check-mu-stmt-list:check-for-block:
19863 81 7/subop/compare *eax 0/imm32/block
19864 75/jump-if-!= break/disp8
19865 $check-mu-stmt-list:block:
19866 (check-mu-block %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
19867 eb/jump $check-mu-stmt-list:continue/disp8
19868 }
19869 {
19870 $check-mu-stmt-list:check-for-stmt1:
19871 81 7/subop/compare *eax 1/imm32/stmt1
19872 0f 85/jump-if-!= break/disp32
19873 $check-mu-stmt-list:stmt1:
19874 (check-mu-stmt %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
19875 eb/jump $check-mu-stmt-list:continue/disp8
19876 }
19877 {
19878 $check-mu-stmt-list:check-for-reg-var-def:
19879 81 7/subop/compare *eax 3/imm32/reg-var-def
19880 0f 85/jump-if-!= break/disp32
19881 $check-mu-stmt-list:reg-var-def:
19882 (check-mu-stmt %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
19883 eb/jump $check-mu-stmt-list:continue/disp8
19884 }
19885 $check-mu-stmt-list:continue:
19886
19887 (lookup *(esi+8) *(esi+0xc))
19888 89/<- %esi 0/r32/eax
19889 e9/jump loop/disp32
19890 }
19891 $check-mu-stmt-list:end:
19892
19893 5e/pop-to-esi
19894 58/pop-to-eax
19895
19896 89/<- %esp 5/r32/ebp
19897 5d/pop-to-ebp
19898 c3/return
19899
19900 check-mu-stmt:
19901
19902 55/push-ebp
19903 89/<- %ebp 4/r32/esp
19904
19905 50/push-eax
19906
19907 (has-primitive-name? *(ebp+8))
19908 3d/compare-eax-and 0/imm32/false
19909 {
19910 74/jump-if-= break/disp8
19911 (check-mu-primitive *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
19912 e9/jump $check-mu-stmt:end/disp32
19913 }
19914
19915
19916 (lookup *_Program-functions *_Program-functions->payload)
19917 (find-matching-function %eax *(ebp+8))
19918 3d/compare-eax-and 0/imm32
19919 {
19920 74/jump-if-= break/disp8
19921 (check-mu-call *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
19922 eb/jump $check-mu-stmt:end/disp8
19923 }
19924
19925 (lookup *_Program-signatures *_Program-signatures->payload)
19926 (find-matching-function %eax *(ebp+8))
19927 3d/compare-eax-and 0/imm32
19928 {
19929 74/jump-if-= break/disp8
19930 (check-mu-call *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
19931 eb/jump $check-mu-stmt:end/disp8
19932 }
19933
19934 e9/jump $check-mu-stmt:unknown-call/disp32
19935 $check-mu-stmt:end:
19936
19937 58/pop-to-eax
19938
19939 89/<- %esp 5/r32/ebp
19940 5d/pop-to-ebp
19941 c3/return
19942
19943 $check-mu-stmt:unknown-call:
19944 (write-buffered *(ebp+0x10) "unknown function '")
19945 8b/-> *(ebp+8) 0/r32/eax
19946 (lookup *(eax+4) *(eax+8))
19947 (write-buffered *(ebp+0x10) %eax)
19948 (write-buffered *(ebp+0x10) "'\n")
19949 (flush *(ebp+0x10))
19950 (stop *(ebp+0x14) 1)
19951
19952
19953 has-primitive-name?:
19954
19955 55/push-ebp
19956 89/<- %ebp 4/r32/esp
19957
19958 51/push-ecx
19959 56/push-esi
19960
19961 8b/-> *(ebp+8) 6/r32/esi
19962 (lookup *(esi+4) *(esi+8))
19963 89/<- %esi 0/r32/eax
19964
19965 (string-equal? %esi "return")
19966 3d/compare-eax-and 0/imm32/false
19967 0f 85/jump-if-!= $has-primitive-name?:end/disp32
19968
19969 (string-equal? %esi "get")
19970 3d/compare-eax-and 0/imm32/false
19971 0f 85/jump-if-!= $has-primitive-name?:end/disp32
19972
19973 (string-equal? %esi "index")
19974 3d/compare-eax-and 0/imm32/false
19975 0f 85/jump-if-!= $has-primitive-name?:end/disp32
19976
19977 (string-equal? %esi "length")
19978 3d/compare-eax-and 0/imm32/false
19979 0f 85/jump-if-!= $has-primitive-name?:end/disp32
19980
19981 (string-equal? %esi "compute-offset")
19982 3d/compare-eax-and 0/imm32/false
19983 0f 85/jump-if-!= $has-primitive-name?:end/disp32
19984
19985 (string-equal? %esi "copy-object")
19986 3d/compare-eax-and 0/imm32/false
19987 0f 85/jump-if-!= $has-primitive-name?:end/disp32
19988
19989 (string-equal? %esi "clear-object")
19990 3d/compare-eax-and 0/imm32/false
19991 0f 85/jump-if-!= $has-primitive-name?:end/disp32
19992
19993 (string-equal? %esi "allocate")
19994 3d/compare-eax-and 0/imm32/false
19995 0f 85/jump-if-!= $has-primitive-name?:end/disp32
19996
19997 (string-equal? %esi "populate")
19998 3d/compare-eax-and 0/imm32/false
19999 0f 85/jump-if-!= $has-primitive-name?:end/disp32
20000
20001 (string-equal? %esi "populate-stream")
20002 3d/compare-eax-and 0/imm32/false
20003 0f 85/jump-if-!= $has-primitive-name?:end/disp32
20004
20005 (string-equal? %esi "read-from-stream")
20006 3d/compare-eax-and 0/imm32/false
20007 0f 85/jump-if-!= $has-primitive-name?:end/disp32
20008
20009 (string-equal? %esi "write-to-stream")
20010 3d/compare-eax-and 0/imm32/false
20011 0f 85/jump-if-!= $has-primitive-name?:end/disp32
20012
20013 b9/copy-to-ecx Primitives/imm32
20014 {
20015 $has-primitive-name?:loop:
20016
20017 81 7/subop/compare %ecx 0/imm32
20018 74/jump-if-= break/disp8
20019
20020 (lookup *ecx *(ecx+4))
20021
20022
20023
20024 (string-equal? %esi %eax)
20025 3d/compare-eax-and 0/imm32/false
20026 75/jump-if-!= $has-primitive-name?:end/disp8
20027 $has-primitive-name?:next-primitive:
20028
20029 (lookup *(ecx+0x3c) *(ecx+0x40))
20030 89/<- %ecx 0/r32/eax
20031
20032 e9/jump loop/disp32
20033 }
20034
20035 b8/copy-to-eax 0/imm32
20036 $has-primitive-name?:end:
20037
20038 5e/pop-to-esi
20039 59/pop-to-ecx
20040
20041 89/<- %esp 5/r32/ebp
20042 5d/pop-to-ebp
20043 c3/return
20044
20045 check-mu-primitive:
20046
20047 55/push-ebp
20048 89/<- %ebp 4/r32/esp
20049
20050 50/push-eax
20051 51/push-ecx
20052
20053 8b/-> *(ebp+8) 0/r32/eax
20054 (lookup *(eax+4) *(eax+8))
20055 89/<- %ecx 0/r32/eax
20056
20057 {
20058 (string-equal? %ecx "copy")
20059 3d/compare-eax-and 0/imm32/false
20060 74/jump-if-= break/disp8
20061 (check-mu-copy-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20062 e9/jump $check-mu-primitive:end/disp32
20063 }
20064
20065 {
20066 (string-equal? %ecx "copy-to")
20067 3d/compare-eax-and 0/imm32/false
20068 74/jump-if-= break/disp8
20069 (check-mu-copy-to-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20070 e9/jump $check-mu-primitive:end/disp32
20071 }
20072
20073 {
20074 (string-equal? %ecx "compare")
20075 3d/compare-eax-and 0/imm32/false
20076 74/jump-if-= break/disp8
20077 (check-mu-compare-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20078 e9/jump $check-mu-primitive:end/disp32
20079 }
20080
20081 {
20082 (string-equal? %ecx "address")
20083 3d/compare-eax-and 0/imm32/false
20084 74/jump-if-= break/disp8
20085 (check-mu-address-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20086 e9/jump $check-mu-primitive:end/disp32
20087 }
20088
20089 {
20090 (string-equal? %ecx "return")
20091 3d/compare-eax-and 0/imm32/false
20092 74/jump-if-= break/disp8
20093 (check-mu-return-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20094 e9/jump $check-mu-primitive:end/disp32
20095 }
20096
20097 {
20098 (string-equal? %ecx "get")
20099 3d/compare-eax-and 0/imm32/false
20100 74/jump-if-= break/disp8
20101 (check-mu-get-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20102 e9/jump $check-mu-primitive:end/disp32
20103 }
20104
20105 {
20106 (string-equal? %ecx "index")
20107 3d/compare-eax-and 0/imm32/false
20108 74/jump-if-= break/disp8
20109 (check-mu-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20110 e9/jump $check-mu-primitive:end/disp32
20111 }
20112
20113 {
20114 (string-equal? %ecx "length")
20115 3d/compare-eax-and 0/imm32/false
20116 74/jump-if-= break/disp8
20117 (check-mu-length-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20118 e9/jump $check-mu-primitive:end/disp32
20119 }
20120
20121 {
20122 (string-equal? %ecx "compute-offset")
20123 3d/compare-eax-and 0/imm32/false
20124 74/jump-if-= break/disp8
20125 (check-mu-compute-offset-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20126 e9/jump $check-mu-primitive:end/disp32
20127 }
20128
20129 {
20130 (string-equal? %ecx "copy-object")
20131 3d/compare-eax-and 0/imm32/false
20132 74/jump-if-= break/disp8
20133 (check-mu-copy-object-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20134 e9/jump $check-mu-primitive:end/disp32
20135 }
20136
20137 {
20138 (string-equal? %ecx "clear-object")
20139 3d/compare-eax-and 0/imm32/false
20140 74/jump-if-= break/disp8
20141 (check-mu-clear-object-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20142 e9/jump $check-mu-primitive:end/disp32
20143 }
20144
20145 {
20146 (string-equal? %ecx "allocate")
20147 3d/compare-eax-and 0/imm32/false
20148 74/jump-if-= break/disp8
20149 (check-mu-allocate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20150 e9/jump $check-mu-primitive:end/disp32
20151 }
20152
20153 {
20154 (string-equal? %ecx "populate")
20155 3d/compare-eax-and 0/imm32/false
20156 74/jump-if-= break/disp8
20157 (check-mu-populate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20158 e9/jump $check-mu-primitive:end/disp32
20159 }
20160
20161 {
20162 (string-equal? %ecx "populate-stream")
20163 3d/compare-eax-and 0/imm32/false
20164 74/jump-if-= break/disp8
20165 (check-mu-populate-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20166 e9/jump $check-mu-primitive:end/disp32
20167 }
20168
20169 {
20170 (string-equal? %ecx "read-from-stream")
20171 3d/compare-eax-and 0/imm32/false
20172 74/jump-if-= break/disp8
20173 (check-mu-read-from-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20174 e9/jump $check-mu-primitive:end/disp32
20175 }
20176
20177 {
20178 (string-equal? %ecx "write-to-stream")
20179 3d/compare-eax-and 0/imm32/false
20180 74/jump-if-= break/disp8
20181 (check-mu-write-to-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20182 e9/jump $check-mu-primitive:end/disp32
20183 }
20184
20185 {
20186 (string-equal? %ecx "convert")
20187 3d/compare-eax-and 0/imm32/false
20188 74/jump-if-= break/disp8
20189 (check-mu-convert-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20190 e9/jump $check-mu-primitive:end/disp32
20191 }
20192
20193 (check-mu-numberlike-primitive *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20194 $check-mu-primitive:end:
20195
20196 59/pop-to-ecx
20197 58/pop-to-eax
20198
20199 89/<- %esp 5/r32/ebp
20200 5d/pop-to-ebp
20201 c3/return
20202
20203
20204 check-mu-numberlike-primitive:
20205
20206 55/push-ebp
20207 89/<- %ebp 4/r32/esp
20208
20209 50/push-eax
20210 51/push-ecx
20211 56/push-esi
20212
20213 8b/-> *(ebp+8) 6/r32/esi
20214
20215 b9/copy-to-ecx 2/imm32
20216
20217
20218 (lookup *(esi+0x14) *(esi+0x18))
20219 {
20220 3d/compare-eax-and 0/imm32
20221 74/jump-if-= break/disp8
20222 $check-mu-numberlike-primitive:output:
20223 (check-mu-numberlike-output %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20224 (lookup *(eax+8) *(eax+0xc))
20225 3d/compare-eax-and 0/imm32
20226 0f 85/jump-if-!= $check-mu-numberlike-primitive:error-too-many-outputs/disp32
20227
20228
20229 49/decrement-ecx
20230 }
20231
20232 (lookup *(esi+0xc) *(esi+0x10))
20233 {
20234 3d/compare-eax-and 0/imm32
20235 0f 84/jump-if-= $check-mu-numberlike-primitive:end/disp32
20236 $check-mu-numberlike-primitive:first-inout:
20237 (check-mu-numberlike-arg %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20238
20239 49/decrement-ecx
20240 }
20241
20242 (lookup *(eax+8) *(eax+0xc))
20243 {
20244 3d/compare-eax-and 0/imm32
20245 74/jump-if-= $check-mu-numberlike-primitive:end/disp8
20246 $check-mu-numberlike-primitive:second-inout:
20247
20248 81 7/subop/compare %ecx 0/imm32
20249 0f 84/jump-if-= $check-mu-numberlike-primitive:error-too-many-inouts/disp32
20250 $check-mu-numberlike-primitive:second-inout-permitted:
20251 (check-mu-numberlike-arg %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20252 }
20253 $check-mu-numberlike-primitive:third-inout:
20254
20255 81 7/subop/compare *(eax+8) 0/imm32
20256 0f 85/jump-if-!= $check-mu-numberlike-primitive:error-too-many-inouts/disp32
20257 $check-mu-numberlike-primitive:end:
20258
20259 5e/pop-to-esi
20260 59/pop-to-ecx
20261 58/pop-to-eax
20262
20263 89/<- %esp 5/r32/ebp
20264 5d/pop-to-ebp
20265 c3/return
20266
20267 $check-mu-numberlike-primitive:error-too-many-inouts:
20268 (write-buffered *(ebp+0x10) "fn ")
20269 8b/-> *(ebp+0xc) 0/r32/eax
20270 (lookup *eax *(eax+4))
20271 (write-buffered *(ebp+0x10) %eax)
20272 (write-buffered *(ebp+0x10) ": stmt ")
20273 (lookup *(esi+4) *(esi+8))
20274 (write-buffered *(ebp+0x10) %eax)
20275 (write-buffered *(ebp+0x10) ": too many inouts; most primitives support at most two arguments, across inouts and outputs\n")
20276 (flush *(ebp+0x10))
20277 (stop *(ebp+0x14) 1)
20278
20279
20280 $check-mu-numberlike-primitive:error-too-many-outputs:
20281 (write-buffered *(ebp+0x10) "fn ")
20282 8b/-> *(ebp+0xc) 0/r32/eax
20283 (lookup *eax *(eax+4))
20284 (write-buffered *(ebp+0x10) %eax)
20285 (write-buffered *(ebp+0x10) ": stmt ")
20286 (lookup *(esi+4) *(esi+8))
20287 (write-buffered *(ebp+0x10) %eax)
20288 (write-buffered *(ebp+0x10) ": too many outputs; most primitives support at most one output\n")
20289 (flush *(ebp+0x10))
20290 (stop *(ebp+0x14) 1)
20291
20292
20293 check-mu-numberlike-arg:
20294
20295 55/push-ebp
20296 89/<- %ebp 4/r32/esp
20297
20298 50/push-eax
20299 56/push-esi
20300
20301 8b/-> *(ebp+8) 0/r32/eax
20302 (lookup *eax *(eax+4))
20303 (lookup *(eax+8) *(eax+0xc))
20304 89/<- %esi 0/r32/eax
20305 $check-mu-numberlike-arg:check-literal:
20306
20307 (is-simple-mu-type? %esi 0)
20308 3d/compare-eax-and 0/imm32/false
20309 0f 85/jump-if-!= $check-mu-numberlike-arg:end/disp32
20310 $check-mu-numberlike-arg:check-addr:
20311
20312 {
20313 (is-mu-addr-type? %esi)
20314 3d/compare-eax-and 0/imm32/false
20315 74/jump-if-= break/disp8
20316 8b/-> *(ebp+8) 0/r32/eax
20317 8b/-> *(eax+0x10) 0/r32/eax
20318 3d/compare-eax-and 0/imm32/false
20319 {
20320 74/jump-if-= break/disp8
20321 (lookup *(esi+0xc) *(esi+0x10))
20322
20323 81 7/subop/compare *(eax+0xc) 0/imm32
20324 {
20325 75/jump-if-!= break/disp8
20326 (lookup *(eax+4) *(eax+8))
20327 }
20328 (is-mu-addr-type? %eax)
20329 3d/compare-eax-and 0/imm32/false
20330 74/jump-if-= $check-mu-numberlike-arg:end/disp8
20331 }
20332 }
20333 $check-mu-numberlike-arg:output-checks:
20334 (check-mu-numberlike-output *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18))
20335 $check-mu-numberlike-arg:end:
20336
20337 5e/pop-to-esi
20338 58/pop-to-eax
20339
20340 89/<- %esp 5/r32/ebp
20341 5d/pop-to-ebp
20342 c3/return
20343
20344 check-mu-numberlike-output:
20345
20346 55/push-ebp
20347 89/<- %ebp 4/r32/esp
20348
20349 50/push-eax
20350
20351 (is-mu-numberlike-output-var? *(ebp+8))
20352 3d/compare-eax-and 0/imm32/false
20353 0f 84/jump-if-= $check-mu-numberlike-output:fail/disp32
20354 $check-mu-numberlike-output:end:
20355
20356 58/pop-to-eax
20357
20358 89/<- %esp 5/r32/ebp
20359 5d/pop-to-ebp
20360 c3/return
20361
20362 $check-mu-numberlike-output:fail:
20363
20364 (write-buffered *(ebp+0x14) "fn ")
20365 8b/-> *(ebp+0x10) 0/r32/eax
20366 (lookup *eax *(eax+4))
20367 (write-buffered *(ebp+0x14) %eax)
20368 (write-buffered *(ebp+0x14) ": stmt ")
20369 8b/-> *(ebp+0xc) 0/r32/eax
20370 (lookup *(eax+4) *(eax+8))
20371 (write-buffered *(ebp+0x14) %eax)
20372 (write-buffered *(ebp+0x14) ": '")
20373 8b/-> *(ebp+8) 0/r32/eax
20374 (lookup *eax *(eax+4))
20375 (lookup *eax *(eax+4))
20376 (write-buffered *(ebp+0x14) %eax)
20377 (write-buffered *(ebp+0x14) "' must be a non-addr non-offset scalar\n")
20378 (flush *(ebp+0x14))
20379 (stop *(ebp+0x18) 1)
20380
20381
20382 is-mu-numberlike-output-var?:
20383
20384 55/push-ebp
20385 89/<- %ebp 4/r32/esp
20386
20387 8b/-> *(ebp+8) 0/r32/eax
20388 (lookup *eax *(eax+4))
20389 (lookup *(eax+8) *(eax+0xc))
20390 (is-mu-numberlike-output? %eax)
20391 $is-mu-numberlike-output-var?:end:
20392
20393 89/<- %esp 5/r32/ebp
20394 5d/pop-to-ebp
20395 c3/return
20396
20397 is-mu-numberlike-output?:
20398
20399 55/push-ebp
20400 89/<- %ebp 4/r32/esp
20401
20402 56/push-esi
20403
20404 8b/-> *(ebp+8) 6/r32/esi
20405 $is-mu-numberlike-output?:check-int:
20406
20407 (is-simple-mu-type? %esi 1)
20408 3d/compare-eax-and 0/imm32/false
20409 0f 85/jump-if-!= $is-mu-numberlike-output?:return-true/disp32
20410 $is-mu-numberlike-output?:check-float:
20411
20412 (is-simple-mu-type? %esi 0xf)
20413 3d/compare-eax-and 0/imm32/false
20414 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8
20415 $is-mu-numberlike-output?:check-boolean:
20416
20417 (is-simple-mu-type? %esi 5)
20418 3d/compare-eax-and 0/imm32/false
20419 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8
20420 $is-mu-numberlike-output?:check-byte:
20421
20422 (is-simple-mu-type? %esi 8)
20423 3d/compare-eax-and 0/imm32/false
20424 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8
20425 $is-mu-numberlike-output?:check-code-point:
20426
20427 (is-simple-mu-type? %esi 0xd)
20428 3d/compare-eax-and 0/imm32/false
20429 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8
20430 $is-mu-numberlike-output?:check-grapheme:
20431
20432 (is-simple-mu-type? %esi 0xe)
20433 3d/compare-eax-and 0/imm32/false
20434 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8
20435 $is-mu-numberlike-output?:return-false:
20436 b8/copy-to-eax 0/imm32/false
20437 eb/jump $is-mu-numberlike-output?:end/disp8
20438 $is-mu-numberlike-output?:return-true:
20439 b8/copy-to-eax 1/imm32/true
20440 $is-mu-numberlike-output?:end:
20441
20442 5e/pop-to-esi
20443
20444 89/<- %esp 5/r32/ebp
20445 5d/pop-to-ebp
20446 c3/return
20447
20448 check-mu-copy-stmt:
20449
20450 55/push-ebp
20451 89/<- %ebp 4/r32/esp
20452
20453 50/push-eax
20454 51/push-ecx
20455 52/push-edx
20456 56/push-esi
20457 57/push-edi
20458
20459 81 5/subop/subtract %esp 0x60/imm32
20460 68/push 0x60/imm32/size
20461 68/push 0/imm32/read
20462 68/push 0/imm32/write
20463 89/<- %edx 4/r32/esp
20464 $check-mu-copy-stmt:get-output:
20465
20466 8b/-> *(ebp+8) 6/r32/esi
20467
20468 (lookup *(esi+0x14) *(esi+0x18))
20469 89/<- %edi 0/r32/eax
20470
20471 3d/compare-eax-and 0/imm32
20472 0f 84/jump-if-= $check-mu-copy-stmt:error-no-output/disp32
20473
20474 (lookup *(edi+8) *(edi+0xc))
20475 3d/compare-eax-and 0/imm32
20476 0f 85/jump-if-!= $check-mu-copy-stmt:error-too-many-outputs/disp32
20477 $check-mu-copy-stmt:get-inout:
20478
20479 (lookup *(esi+0xc) *(esi+0x10))
20480 89/<- %esi 0/r32/eax
20481
20482 3d/compare-eax-and 0/imm32
20483 0f 84/jump-if-= $check-mu-copy-stmt:error-no-inout/disp32
20484
20485 (lookup *(esi+8) *(esi+0xc))
20486 3d/compare-eax-and 0/imm32
20487 0f 85/jump-if-!= $check-mu-copy-stmt:error-too-many-inouts/disp32
20488 $check-mu-copy-stmt:types:
20489
20490 (lookup *esi *(esi+4))
20491 (lookup *(eax+8) *(eax+0xc))
20492 89/<- %ecx 0/r32/eax
20493
20494 8b/-> *(esi+0x10) 0/r32/eax
20495 3d/compare-eax-and 0/imm32/false
20496 {
20497 74/jump-if-= break/disp8
20498 (lookup *(ecx+0xc) *(ecx+0x10))
20499
20500 81 7/subop/compare *(eax+0xc) 0/imm32
20501 {
20502 75/jump-if-!= break/disp8
20503 (lookup *(eax+4) *(eax+8))
20504 }
20505 89/<- %ecx 0/r32/eax
20506 }
20507
20508 (lookup *edi *(edi+4))
20509 (lookup *(eax+0x18) *(eax+0x1c))
20510 3d/compare-eax-and 0/imm32
20511 0f 84/jump-if-= $check-mu-copy-stmt:error-output-not-in-register/disp32
20512
20513 (lookup *esi *(esi+4))
20514 (size-of %eax)
20515 3d/compare-eax-and 4/imm32
20516 0f 8f/jump-if-> $check-mu-copy-stmt:error-inout-too-large/disp32
20517
20518 (lookup *edi *(edi+4))
20519 (lookup *(eax+8) *(eax+0xc))
20520
20521 (type-match? %eax %ecx %edx)
20522 3d/compare-eax-and 0/imm32
20523 0f 85/jump-if-!= $check-mu-copy-stmt:end/disp32
20524
20525 {
20526 (lookup *edi *(edi+4))
20527 (lookup *(eax+8) *(eax+0xc))
20528 (is-mu-addr-type? %eax)
20529 3d/compare-eax-and 0/imm32/false
20530 74/jump-if-= break/disp8
20531 (lookup *esi *(esi+4))
20532 (lookup *eax *(eax+4))
20533 (string-equal? %eax "0")
20534 3d/compare-eax-and 0/imm32/false
20535 74/jump-if-= break/disp8
20536 e9/jump $check-mu-copy-stmt:end/disp32
20537 }
20538
20539 {
20540 (lookup *edi *(edi+4))
20541 (lookup *(eax+8) *(eax+0xc))
20542 81 7/subop/compare *eax 0/imm32/false
20543 75/jump-if-!= break/disp8
20544 (lookup *(eax+4) *(eax+8))
20545 (is-simple-mu-type? %eax 7)
20546 3d/compare-eax-and 0/imm32/false
20547 74/jump-if-= break/disp8
20548 (lookup *esi *(esi+4))
20549 (lookup *eax *(eax+4))
20550 (string-equal? %eax "0")
20551 3d/compare-eax-and 0/imm32/false
20552 74/jump-if-= break/disp8
20553 eb/jump $check-mu-copy-stmt:end/disp8
20554 }
20555
20556 (check-mu-numberlike-output %edi *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20557 $check-mu-copy-stmt:end:
20558
20559 81 0/subop/add %esp 0x6c/imm32
20560
20561 5f/pop-to-edi
20562 5e/pop-to-esi
20563 5a/pop-to-edx
20564 59/pop-to-ecx
20565 58/pop-to-eax
20566
20567 89/<- %esp 5/r32/ebp
20568 5d/pop-to-ebp
20569 c3/return
20570
20571 $check-mu-copy-stmt:error-no-inout:
20572 (write-buffered *(ebp+0x10) "fn ")
20573 8b/-> *(ebp+0xc) 0/r32/eax
20574 (lookup *eax *(eax+4))
20575 (write-buffered *(ebp+0x10) %eax)
20576 (write-buffered *(ebp+0x10) ": stmt 'copy' expects an inout\n")
20577 (flush *(ebp+0x10))
20578 (stop *(ebp+0x14) 1)
20579
20580
20581 $check-mu-copy-stmt:error-too-many-inouts:
20582 (write-buffered *(ebp+0x10) "fn ")
20583 8b/-> *(ebp+0xc) 0/r32/eax
20584 (lookup *eax *(eax+4))
20585 (write-buffered *(ebp+0x10) %eax)
20586 (write-buffered *(ebp+0x10) ": stmt 'copy' must have just one inout\n")
20587 (flush *(ebp+0x10))
20588 (stop *(ebp+0x14) 1)
20589
20590
20591 $check-mu-copy-stmt:error-no-output:
20592 (write-buffered *(ebp+0x10) "fn ")
20593 8b/-> *(ebp+0xc) 0/r32/eax
20594 (lookup *eax *(eax+4))
20595 (write-buffered *(ebp+0x10) %eax)
20596 (write-buffered *(ebp+0x10) ": stmt 'copy' expects an output\n")
20597 (flush *(ebp+0x10))
20598 (stop *(ebp+0x14) 1)
20599
20600
20601 $check-mu-copy-stmt:error-output-not-in-register:
20602 (write-buffered *(ebp+0x10) "fn ")
20603 8b/-> *(ebp+0xc) 0/r32/eax
20604 (lookup *eax *(eax+4))
20605 (write-buffered *(ebp+0x10) %eax)
20606 (write-buffered *(ebp+0x10) ": stmt copy: output '")
20607 (lookup *edi *(edi+4))
20608 (lookup *eax *(eax+4))
20609 (write-buffered *(ebp+0x10) %eax)
20610 (write-buffered *(ebp+0x10) "' not in a register\n")
20611 (flush *(ebp+0x10))
20612 (stop *(ebp+0x14) 1)
20613
20614
20615 $check-mu-copy-stmt:error-too-many-outputs:
20616 (write-buffered *(ebp+0x10) "fn ")
20617 8b/-> *(ebp+0xc) 0/r32/eax
20618 (lookup *eax *(eax+4))
20619 (write-buffered *(ebp+0x10) %eax)
20620 (write-buffered *(ebp+0x10) ": stmt 'copy' must have just one output\n")
20621 (flush *(ebp+0x10))
20622 (stop *(ebp+0x14) 1)
20623
20624
20625 $check-mu-copy-stmt:error-inout-too-large:
20626 (write-buffered *(ebp+0x10) "fn ")
20627 8b/-> *(ebp+0xc) 0/r32/eax
20628 (lookup *eax *(eax+4))
20629 (write-buffered *(ebp+0x10) %eax)
20630 (write-buffered *(ebp+0x10) ": stmt copy: '")
20631 (lookup *esi *(esi+4))
20632 (lookup *eax *(eax+4))
20633 (write-buffered *(ebp+0x10) %eax)
20634 (write-buffered *(ebp+0x10) "' is too large to fit in a register\n")
20635 (flush *(ebp+0x10))
20636 (stop *(ebp+0x14) 1)
20637
20638
20639 check-mu-copy-to-stmt:
20640
20641 55/push-ebp
20642 89/<- %ebp 4/r32/esp
20643
20644 50/push-eax
20645 51/push-ecx
20646 52/push-edx
20647 53/push-ebx
20648 56/push-esi
20649 57/push-edi
20650
20651 81 5/subop/subtract %esp 0x60/imm32
20652 68/push 0x60/imm32/size
20653 68/push 0/imm32/read
20654 68/push 0/imm32/write
20655 89/<- %edx 4/r32/esp
20656
20657 8b/-> *(ebp+8) 6/r32/esi
20658 $check-mu-copy-to-stmt:check-for-output:
20659
20660 (lookup *(esi+0x14) *(esi+0x18))
20661 3d/compare-eax-and 0/imm32
20662 0f 85/jump-if-!= $check-mu-copy-to-stmt:error-too-many-outputs/disp32
20663 $check-mu-copy-to-stmt:get-dest:
20664
20665 (lookup *(esi+0xc) *(esi+0x10))
20666 89/<- %edi 0/r32/eax
20667
20668 3d/compare-eax-and 0/imm32
20669 0f 84/jump-if-= $check-mu-copy-to-stmt:error-incorrect-inouts/disp32
20670 $check-mu-copy-to-stmt:get-src:
20671
20672 (lookup *(edi+8) *(edi+0xc))
20673 89/<- %esi 0/r32/eax
20674
20675 3d/compare-eax-and 0/imm32
20676 0f 84/jump-if-= $check-mu-copy-to-stmt:error-incorrect-inouts/disp32
20677
20678 (lookup *(esi+8) *(esi+0xc))
20679 3d/compare-eax-and 0/imm32
20680 0f 85/jump-if-!= $check-mu-copy-to-stmt:error-incorrect-inouts/disp32
20681 $check-mu-copy-to-stmt:types:
20682
20683 (lookup *esi *(esi+4))
20684 (lookup *(eax+8) *(eax+0xc))
20685 89/<- %ecx 0/r32/eax
20686
20687
20688 {
20689 (lookup *esi *(esi+4))
20690 (lookup *(eax+0x8) *(eax+0xc))
20691 (is-simple-mu-type? %eax 0)
20692 3d/compare-eax-and 0/imm32
20693 75/jump-if-!= break/disp8
20694 (lookup *esi *(esi+4))
20695 (lookup *(eax+0x18) *(eax+0x1c))
20696 3d/compare-eax-and 0/imm32
20697 75/jump-if-!= break/disp8
20698 e9/jump $check-mu-copy-to-stmt:error-src-not-literal-or-in-register/disp32
20699 }
20700
20701 (lookup *esi *(esi+4))
20702 (size-of %eax)
20703 3d/compare-eax-and 4/imm32
20704 0f 8f/jump-if-> $check-mu-copy-to-stmt:error-src-too-large/disp32
20705
20706 (lookup *edi *(edi+4))
20707 (lookup *(eax+8) *(eax+0xc))
20708 89/<- %ebx 0/r32/eax
20709
20710 8b/-> *(edi+0x10) 0/r32/eax
20711 3d/compare-eax-and 0/imm32/false
20712 {
20713 74/jump-if-= break/disp8
20714 (lookup *(ebx+0xc) *(ebx+0x10))
20715
20716 81 7/subop/compare *(eax+0xc) 0/imm32
20717 {
20718 75/jump-if-!= break/disp8
20719 (lookup *(eax+4) *(eax+8))
20720 }
20721 89/<- %ebx 0/r32/eax
20722 }
20723
20724 (type-match? %ebx %ecx %edx)
20725 3d/compare-eax-and 0/imm32
20726 0f 85/jump-if-!= $check-mu-copy-to-stmt:end/disp32
20727
20728 {
20729 (lookup *edi *(edi+4))
20730 (lookup *(eax+8) *(eax+0xc))
20731 (is-mu-addr-type? %eax)
20732 3d/compare-eax-and 0/imm32/false
20733 74/jump-if-= break/disp8
20734 (lookup *esi *(esi+4))
20735 (lookup *eax *(eax+4))
20736 (string-equal? %eax "0")
20737 3d/compare-eax-and 0/imm32/false
20738 74/jump-if-= break/disp8
20739 eb/jump $check-mu-copy-to-stmt:end/disp8
20740 }
20741
20742 (check-mu-numberlike-arg %edi *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20743 $check-mu-copy-to-stmt:end:
20744
20745 81 0/subop/add %esp 0x6c/imm32
20746
20747 5f/pop-to-edi
20748 5e/pop-to-esi
20749 5b/pop-to-ebx
20750 5a/pop-to-edx
20751 59/pop-to-ecx
20752 58/pop-to-eax
20753
20754 89/<- %esp 5/r32/ebp
20755 5d/pop-to-ebp
20756 c3/return
20757
20758 $check-mu-copy-to-stmt:error-incorrect-inouts:
20759 (write-buffered *(ebp+0x10) "fn ")
20760 8b/-> *(ebp+0xc) 0/r32/eax
20761 (lookup *eax *(eax+4))
20762 (write-buffered *(ebp+0x10) %eax)
20763 (write-buffered *(ebp+0x10) ": stmt 'copy-to' must have two inouts\n")
20764 (flush *(ebp+0x10))
20765 (stop *(ebp+0x14) 1)
20766
20767
20768 $check-mu-copy-to-stmt:error-too-many-outputs:
20769 (write-buffered *(ebp+0x10) "fn ")
20770 8b/-> *(ebp+0xc) 0/r32/eax
20771 (lookup *eax *(eax+4))
20772 (write-buffered *(ebp+0x10) %eax)
20773 (write-buffered *(ebp+0x10) ": stmt 'copy-to' must not have any outputs\n")
20774 (flush *(ebp+0x10))
20775 (stop *(ebp+0x14) 1)
20776
20777
20778 $check-mu-copy-to-stmt:error-src-not-literal-or-in-register:
20779 (write-buffered *(ebp+0x10) "fn ")
20780 8b/-> *(ebp+0xc) 0/r32/eax
20781 (lookup *eax *(eax+4))
20782 (write-buffered *(ebp+0x10) %eax)
20783 (write-buffered *(ebp+0x10) ": stmt copy-to: source (second inout) is in memory\n")
20784 (flush *(ebp+0x10))
20785 (stop *(ebp+0x14) 1)
20786
20787
20788 $check-mu-copy-to-stmt:error-src-too-large:
20789 (write-buffered *(ebp+0x10) "fn ")
20790 8b/-> *(ebp+0xc) 0/r32/eax
20791 (lookup *eax *(eax+4))
20792 (write-buffered *(ebp+0x10) %eax)
20793 (write-buffered *(ebp+0x10) ": stmt copy-to: '")
20794 (lookup *esi *(esi+4))
20795 (lookup *eax *(eax+4))
20796 (write-buffered *(ebp+0x10) %eax)
20797 (write-buffered *(ebp+0x10) "' is too large to copy\n")
20798 (flush *(ebp+0x10))
20799 (stop *(ebp+0x14) 1)
20800
20801
20802 check-mu-compare-stmt:
20803
20804 55/push-ebp
20805 89/<- %ebp 4/r32/esp
20806
20807 50/push-eax
20808 51/push-ecx
20809 52/push-edx
20810 53/push-ebx
20811 56/push-esi
20812 57/push-edi
20813
20814 81 5/subop/subtract %esp 0x60/imm32
20815 68/push 0x60/imm32/size
20816 68/push 0/imm32/read
20817 68/push 0/imm32/write
20818 89/<- %edx 4/r32/esp
20819
20820 8b/-> *(ebp+8) 6/r32/esi
20821 $check-mu-compare-stmt:check-for-output:
20822
20823 (lookup *(esi+0x14) *(esi+0x18))
20824 3d/compare-eax-and 0/imm32
20825 0f 85/jump-if-!= $check-mu-compare-stmt:error-too-many-outputs/disp32
20826 $check-mu-compare-stmt:get-left:
20827
20828 (lookup *(esi+0xc) *(esi+0x10))
20829 89/<- %edi 0/r32/eax
20830
20831 3d/compare-eax-and 0/imm32
20832 0f 84/jump-if-= $check-mu-compare-stmt:error-incorrect-inouts/disp32
20833 $check-mu-compare-stmt:get-right:
20834
20835 (lookup *(edi+8) *(edi+0xc))
20836 89/<- %esi 0/r32/eax
20837
20838 3d/compare-eax-and 0/imm32
20839 0f 84/jump-if-= $check-mu-compare-stmt:error-incorrect-inouts/disp32
20840
20841 (lookup *(esi+8) *(esi+0xc))
20842 3d/compare-eax-and 0/imm32
20843 0f 85/jump-if-!= $check-mu-compare-stmt:error-incorrect-inouts/disp32
20844
20845 {
20846 $check-mu-compare-stmt:both-in-mem:
20847 (lookup *esi *(esi+4))
20848 (lookup *(eax+0x8) *(eax+0xc))
20849 (is-simple-mu-type? %eax 0)
20850 3d/compare-eax-and 0/imm32
20851 0f 85/jump-if-!= break/disp32
20852 (lookup *esi *(esi+4))
20853 (lookup *(eax+0x18) *(eax+0x1c))
20854 3d/compare-eax-and 0/imm32
20855 75/jump-if-!= break/disp8
20856 (lookup *edi *(edi+4))
20857 (lookup *(eax+0x8) *(eax+0xc))
20858 (is-simple-mu-type? %eax 0)
20859 3d/compare-eax-and 0/imm32
20860 75/jump-if-!= break/disp8
20861 (lookup *edi *(edi+4))
20862 (lookup *(eax+0x18) *(eax+0x1c))
20863 3d/compare-eax-and 0/imm32
20864 75/jump-if-!= break/disp8
20865 e9/jump $check-mu-compare-stmt:error-both-in-memory/disp32
20866 }
20867 $check-mu-compare-stmt:types:
20868
20869 (lookup *esi *(esi+4))
20870 (lookup *(eax+8) *(eax+0xc))
20871 89/<- %ecx 0/r32/eax
20872
20873 8b/-> *(esi+0x10) 0/r32/eax
20874 3d/compare-eax-and 0/imm32/false
20875 {
20876 74/jump-if-= break/disp8
20877 (lookup *(ecx+0xc) *(ecx+0x10))
20878
20879 81 7/subop/compare *(eax+0xc) 0/imm32
20880 {
20881 75/jump-if-!= break/disp8
20882 (lookup *(eax+4) *(eax+8))
20883 }
20884 89/<- %ecx 0/r32/eax
20885 }
20886
20887 (lookup *esi *(esi+4))
20888 (size-of %eax)
20889 3d/compare-eax-and 4/imm32
20890 0f 8f/jump-if-> $check-mu-compare-stmt:error-right-too-large/disp32
20891
20892 (lookup *edi *(edi+4))
20893 (size-of %eax)
20894 3d/compare-eax-and 4/imm32
20895 0f 8f/jump-if-> $check-mu-compare-stmt:error-left-too-large/disp32
20896
20897 (lookup *edi *(edi+4))
20898 (lookup *(eax+8) *(eax+0xc))
20899 89/<- %ebx 0/r32/eax
20900
20901 8b/-> *(edi+0x10) 0/r32/eax
20902 3d/compare-eax-and 0/imm32/false
20903 {
20904 74/jump-if-= break/disp8
20905 (lookup *(ebx+0xc) *(ebx+0x10))
20906
20907 81 7/subop/compare *(eax+0xc) 0/imm32
20908 {
20909 75/jump-if-!= break/disp8
20910 (lookup *(eax+4) *(eax+8))
20911 }
20912 89/<- %ebx 0/r32/eax
20913 }
20914
20915 (type-match? %ebx %ecx %edx)
20916 3d/compare-eax-and 0/imm32
20917 0f 85/jump-if-!= $check-mu-compare-stmt:end/disp32
20918
20919 {
20920 (lookup *edi *(edi+4))
20921 (lookup *(eax+8) *(eax+0xc))
20922 (is-mu-addr-type? %eax)
20923 3d/compare-eax-and 0/imm32/false
20924 74/jump-if-= break/disp8
20925 (lookup *esi *(esi+4))
20926 (lookup *eax *(eax+4))
20927 (string-equal? %eax "0")
20928 3d/compare-eax-and 0/imm32/false
20929 74/jump-if-= break/disp8
20930 eb/jump $check-mu-compare-stmt:end/disp8
20931 }
20932
20933 (check-mu-numberlike-arg %edi *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
20934 $check-mu-compare-stmt:end:
20935
20936 81 0/subop/add %esp 0x6c/imm32
20937
20938 5f/pop-to-edi
20939 5e/pop-to-esi
20940 5b/pop-to-ebx
20941 5a/pop-to-edx
20942 59/pop-to-ecx
20943 58/pop-to-eax
20944
20945 89/<- %esp 5/r32/ebp
20946 5d/pop-to-ebp
20947 c3/return
20948
20949 $check-mu-compare-stmt:error-incorrect-inouts:
20950 (write-buffered *(ebp+0x10) "fn ")
20951 8b/-> *(ebp+0xc) 0/r32/eax
20952 (lookup *eax *(eax+4))
20953 (write-buffered *(ebp+0x10) %eax)
20954 (write-buffered *(ebp+0x10) ": stmt 'compare' must have two inouts\n")
20955 (flush *(ebp+0x10))
20956 (stop *(ebp+0x14) 1)
20957
20958
20959 $check-mu-compare-stmt:error-too-many-outputs:
20960 (write-buffered *(ebp+0x10) "fn ")
20961 8b/-> *(ebp+0xc) 0/r32/eax
20962 (lookup *eax *(eax+4))
20963 (write-buffered *(ebp+0x10) %eax)
20964 (write-buffered *(ebp+0x10) ": stmt 'compare' must not have any outputs\n")
20965 (flush *(ebp+0x10))
20966 (stop *(ebp+0x14) 1)
20967
20968
20969 $check-mu-compare-stmt:error-both-in-memory:
20970 (write-buffered *(ebp+0x10) "fn ")
20971 8b/-> *(ebp+0xc) 0/r32/eax
20972 (lookup *eax *(eax+4))
20973 (write-buffered *(ebp+0x10) %eax)
20974 (write-buffered *(ebp+0x10) ": stmt compare: both inouts are in memory\n")
20975 (flush *(ebp+0x10))
20976 (stop *(ebp+0x14) 1)
20977
20978
20979 $check-mu-compare-stmt:error-left-too-large:
20980 (write-buffered *(ebp+0x10) "fn ")
20981 8b/-> *(ebp+0xc) 0/r32/eax
20982 (lookup *eax *(eax+4))
20983 (write-buffered *(ebp+0x10) %eax)
20984 (write-buffered *(ebp+0x10) ": stmt compare: '")
20985 (lookup *edi *(edi+4))
20986 (lookup *eax *(eax+4))
20987 (write-buffered *(ebp+0x10) %eax)
20988 (write-buffered *(ebp+0x10) "' is too large to compare\n")
20989 (flush *(ebp+0x10))
20990 (stop *(ebp+0x14) 1)
20991
20992
20993 $check-mu-compare-stmt:error-right-too-large:
20994 (write-buffered *(ebp+0x10) "fn ")
20995 8b/-> *(ebp+0xc) 0/r32/eax
20996 (lookup *eax *(eax+4))
20997 (write-buffered *(ebp+0x10) %eax)
20998 (write-buffered *(ebp+0x10) ": stmt compare: '")
20999 (lookup *esi *(esi+4))
21000 (lookup *eax *(eax+4))
21001 (write-buffered *(ebp+0x10) %eax)
21002 (write-buffered *(ebp+0x10) "' is too large to compare\n")
21003 (flush *(ebp+0x10))
21004 (stop *(ebp+0x14) 1)
21005
21006
21007 check-mu-address-stmt:
21008
21009 55/push-ebp
21010 89/<- %ebp 4/r32/esp
21011
21012 50/push-eax
21013 51/push-ecx
21014 52/push-edx
21015 56/push-esi
21016 57/push-edi
21017 $check-mu-address-stmt:get-output:
21018
21019 8b/-> *(ebp+8) 6/r32/esi
21020
21021 (lookup *(esi+0x14) *(esi+0x18))
21022 89/<- %edi 0/r32/eax
21023
21024 3d/compare-eax-and 0/imm32
21025 0f 84/jump-if-= $check-mu-address-stmt:error-no-output/disp32
21026
21027 (lookup *(edi+8) *(edi+0xc))
21028 3d/compare-eax-and 0/imm32
21029 0f 85/jump-if-!= $check-mu-address-stmt:error-too-many-outputs/disp32
21030 $check-mu-address-stmt:get-inout:
21031
21032 (lookup *(esi+0xc) *(esi+0x10))
21033 89/<- %esi 0/r32/eax
21034
21035 3d/compare-eax-and 0/imm32
21036 0f 84/jump-if-= $check-mu-address-stmt:error-no-inout/disp32
21037
21038 (lookup *(esi+8) *(esi+0xc))
21039 3d/compare-eax-and 0/imm32
21040 0f 85/jump-if-!= $check-mu-address-stmt:error-too-many-inouts/disp32
21041 $check-mu-address-stmt:types:
21042
21043 (lookup *edi *(edi+4))
21044 (lookup *(eax+0x18) *(eax+0x1c))
21045 3d/compare-eax-and 0/imm32
21046 0f 84/jump-if-= $check-mu-address-stmt:error-output-not-in-register/disp32
21047
21048 (lookup *edi *(edi+4))
21049 (lookup *(eax+8) *(eax+0xc))
21050 89/<- %edx 0/r32/eax
21051
21052 (is-mu-addr-type? %edx)
21053 3d/compare-eax-and 0/imm32/false
21054 0f 84/jump-if-= $check-mu-address-stmt:error-output-not-address/disp32
21055
21056 (lookup *(edx+0xc) *(edx+0x10))
21057
21058 81 7/subop/compare *(eax+0xc) 0/imm32
21059 {
21060 75/jump-if-!= break/disp8
21061 (lookup *(eax+4) *(eax+8))
21062 }
21063 89/<- %edx 0/r32/eax
21064
21065 (lookup *esi *(esi+4))
21066 (lookup *(eax+8) *(eax+0xc))
21067 89/<- %ecx 0/r32/eax
21068
21069 8b/-> *(esi+0x10) 0/r32/eax
21070 3d/compare-eax-and 0/imm32/false
21071 {
21072 74/jump-if-= break/disp8
21073 (lookup *(ecx+0xc) *(ecx+0x10))
21074
21075 81 7/subop/compare *(eax+0xc) 0/imm32
21076 {
21077 75/jump-if-!= break/disp8
21078 (lookup *(eax+4) *(eax+8))
21079 }
21080 89/<- %ecx 0/r32/eax
21081 }
21082
21083 (type-equal-ignoring-capacity? %edx %ecx)
21084 3d/compare-eax-and 0/imm32
21085 0f 84/jump-if-= $check-mu-address-stmt:error-type-mismatch/disp32
21086 $check-mu-address-stmt:end:
21087
21088 5f/pop-to-edi
21089 5e/pop-to-esi
21090 5a/pop-to-edx
21091 59/pop-to-ecx
21092 58/pop-to-eax
21093
21094 89/<- %esp 5/r32/ebp
21095 5d/pop-to-ebp
21096 c3/return
21097
21098 $check-mu-address-stmt:error-no-inout:
21099 (write-buffered *(ebp+0x10) "fn ")
21100 8b/-> *(ebp+0xc) 0/r32/eax
21101 (lookup *eax *(eax+4))
21102 (write-buffered *(ebp+0x10) %eax)
21103 (write-buffered *(ebp+0x10) ": stmt 'address' expects an inout\n")
21104 (flush *(ebp+0x10))
21105 (stop *(ebp+0x14) 1)
21106
21107
21108 $check-mu-address-stmt:error-too-many-inouts:
21109 (write-buffered *(ebp+0x10) "fn ")
21110 8b/-> *(ebp+0xc) 0/r32/eax
21111 (lookup *eax *(eax+4))
21112 (write-buffered *(ebp+0x10) %eax)
21113 (write-buffered *(ebp+0x10) ": stmt 'address' must have just one inout\n")
21114 (flush *(ebp+0x10))
21115 (stop *(ebp+0x14) 1)
21116
21117
21118 $check-mu-address-stmt:error-no-output:
21119 (write-buffered *(ebp+0x10) "fn ")
21120 8b/-> *(ebp+0xc) 0/r32/eax
21121 (lookup *eax *(eax+4))
21122 (write-buffered *(ebp+0x10) %eax)
21123 (write-buffered *(ebp+0x10) ": stmt 'address' expects an output\n")
21124 (flush *(ebp+0x10))
21125 (stop *(ebp+0x14) 1)
21126
21127
21128 $check-mu-address-stmt:error-output-not-in-register:
21129 (write-buffered *(ebp+0x10) "fn ")
21130 8b/-> *(ebp+0xc) 0/r32/eax
21131 (lookup *eax *(eax+4))
21132 (write-buffered *(ebp+0x10) %eax)
21133 (write-buffered *(ebp+0x10) ": stmt address: output '")
21134 (lookup *edi *(edi+4))
21135 (lookup *eax *(eax+4))
21136 (write-buffered *(ebp+0x10) %eax)
21137 (write-buffered *(ebp+0x10) "' not in a register\n")
21138 (flush *(ebp+0x10))
21139 (stop *(ebp+0x14) 1)
21140
21141
21142 $check-mu-address-stmt:error-too-many-outputs:
21143 (write-buffered *(ebp+0x10) "fn ")
21144 8b/-> *(ebp+0xc) 0/r32/eax
21145 (lookup *eax *(eax+4))
21146 (write-buffered *(ebp+0x10) %eax)
21147 (write-buffered *(ebp+0x10) ": stmt 'address' must have just one output\n")
21148 (flush *(ebp+0x10))
21149 (stop *(ebp+0x14) 1)
21150
21151
21152 $check-mu-address-stmt:error-output-not-address:
21153 (write-buffered *(ebp+0x10) "fn ")
21154 8b/-> *(ebp+0xc) 0/r32/eax
21155 (lookup *eax *(eax+4))
21156 (write-buffered *(ebp+0x10) %eax)
21157 (write-buffered *(ebp+0x10) ": stmt address: output '")
21158 (lookup *edi *(edi+4))
21159 (lookup *eax *(eax+4))
21160 (write-buffered *(ebp+0x10) %eax)
21161 (write-buffered *(ebp+0x10) "' is not an addr\n")
21162 (flush *(ebp+0x10))
21163 (stop *(ebp+0x14) 1)
21164
21165
21166 $check-mu-address-stmt:error-type-mismatch:
21167 (write-buffered *(ebp+0x10) "fn ")
21168 8b/-> *(ebp+0xc) 0/r32/eax
21169 (lookup *eax *(eax+4))
21170 (write-buffered *(ebp+0x10) %eax)
21171 (write-buffered *(ebp+0x10) ": stmt address: output '")
21172 (lookup *edi *(edi+4))
21173 (lookup *eax *(eax+4))
21174 (write-buffered *(ebp+0x10) %eax)
21175 (write-buffered *(ebp+0x10) "' cannot hold address of '")
21176 (lookup *esi *(esi+4))
21177 (lookup *eax *(eax+4))
21178 (write-buffered *(ebp+0x10) %eax)
21179 (write-buffered *(ebp+0x10) "'\n")
21180 (flush *(ebp+0x10))
21181 (stop *(ebp+0x14) 1)
21182
21183
21184 type-equal-ignoring-capacity?:
21185
21186 55/push-ebp
21187 89/<- %ebp 4/r32/esp
21188
21189 51/push-ecx
21190 52/push-edx
21191 53/push-ebx
21192
21193 8b/-> *(ebp+8) 1/r32/ecx
21194
21195 8b/-> *(ebp+0xc) 3/r32/ebx
21196
21197 81 7/subop/compare *ecx 0/imm32/false
21198 0f 85/jump-if-!= $type-equal-ignoring-capacity?:base-case/disp32
21199
21200 (lookup *(ecx+4) *(ecx+8))
21201 89/<- %edx 0/r32/eax
21202 (lookup *(ebx+4) *(ebx+8))
21203 (type-equal? %edx %eax)
21204 3d/compare-eax-and 0/imm32/false
21205 0f 84/jump-if-= $type-equal-ignoring-capacity?:end/disp32
21206
21207 {
21208 (is-mu-array? %edx)
21209 3d/compare-eax-and 0/imm32/false
21210 75/jump-if-!= break/disp8
21211 $type-equal-ignoring-capacity?:array:
21212
21213 (lookup *(ecx+0xc) *(ecx+0x10))
21214 (lookup *(eax+4) *(eax+8))
21215 89/<- %ecx 0/r32/eax
21216
21217 (lookup *(ebx+0xc) *(ebx+0x10))
21218 (lookup *(eax+4) *(eax+8))
21219 89/<- %ebx 0/r32/eax
21220 eb/jump $type-equal-ignoring-capacity?:base-case/disp8
21221 }
21222
21223 {
21224 (is-mu-stream? %edx)
21225 3d/compare-eax-and 0/imm32/false
21226 75/jump-if-!= break/disp8
21227 $type-equal-ignoring-capacity?:stream:
21228
21229 (lookup *(ecx+0xc) *(ecx+0x10))
21230 (lookup *(eax+4) *(eax+8))
21231 89/<- %ecx 0/r32/eax
21232
21233 (lookup *(ebx+0xc) *(ebx+0x10))
21234 (lookup *(eax+4) *(eax+8))
21235 89/<- %ebx 0/r32/eax
21236 eb/jump $type-equal-ignoring-capacity?:base-case/disp8
21237 }
21238 $type-equal-ignoring-capacity?:base-case:
21239
21240 (type-equal? %ecx %ebx)
21241 $type-equal-ignoring-capacity?:end:
21242
21243 5b/pop-to-ebx
21244 5a/pop-to-edx
21245 59/pop-to-ecx
21246
21247 89/<- %esp 5/r32/ebp
21248 5d/pop-to-ebp
21249 c3/return
21250
21251 check-mu-return-stmt:
21252
21253 55/push-ebp
21254 89/<- %ebp 4/r32/esp
21255
21256 50/push-eax
21257 51/push-ecx
21258 52/push-edx
21259 53/push-ebx
21260 56/push-esi
21261 57/push-edi
21262
21263 81 5/subop/subtract %esp 0x60/imm32
21264 68/push 0x60/imm32/size
21265 68/push 0/imm32/read
21266 68/push 0/imm32/write
21267 89/<- %edx 4/r32/esp
21268
21269 8b/-> *(ebp+0xc) 0/r32/eax
21270 (lookup *(eax+0x10) *(eax+0x14))
21271 89/<- %esi 0/r32/eax
21272
21273 89/<- %ebx 0/r32/eax
21274
21275 8b/-> *(ebp+8) 0/r32/eax
21276 (lookup *(eax+0xc) *(eax+0x10))
21277 89/<- %edi 0/r32/eax
21278 {
21279
21280 81 7/subop/compare %ebx 0/imm32
21281 0f 84/jump-if-= break/disp32
21282
21283 81 7/subop/compare %edi 0/imm32
21284 0f 84/jump-if-= $check-mu-return-stmt:error-too-few-inouts/disp32
21285
21286 (lookup *ebx *(ebx+4))
21287 (lookup *(eax+8) *(eax+0xc))
21288 89/<- %ecx 0/r32/eax
21289
21290 (lookup *edi *(edi+4))
21291 (lookup *(eax+8) *(eax+0xc))
21292
21293 81 7/subop/compare *(edi+0x10) 0/imm32/false
21294 {
21295 74/jump-if-= break/disp8
21296 (lookup *(eax+0xc) *(eax+0x10))
21297
21298 81 7/subop/compare *(eax+0xc) 0/imm32
21299 75/jump-if-!= break/disp8
21300 (lookup *(eax+4) *(eax+8))
21301 }
21302
21303 (type-match? %ecx %eax %edx)
21304 3d/compare-eax-and 0/imm32/false
21305 0f 84/jump-if-= $check-mu-return-stmt:error1/disp32
21306
21307 (register-within-list-with-conflict? %edi %esi %ebx *(ebp+8))
21308 3d/compare-eax-and 0/imm32/false
21309 0f 85/jump-if-!= $check-mu-return-stmt:error2/disp32
21310
21311 (lookup *(ebx+8) *(ebx+0xc))
21312 89/<- %ebx 0/r32/eax
21313
21314 (lookup *(edi+8) *(edi+0xc))
21315 89/<- %edi 0/r32/eax
21316
21317 e9/jump loop/disp32
21318 }
21319
21320 81 7/subop/compare %edi 0/imm32
21321 0f 85/jump-if-!= $check-mu-return-stmt:error-too-many-inouts/disp32
21322 $check-mu-return-stmt:end:
21323
21324 81 0/subop/add %esp 0x6c/imm32
21325
21326 5f/pop-to-edi
21327 5e/pop-to-esi
21328 5b/pop-to-ebx
21329 5a/pop-to-edx
21330 59/pop-to-ecx
21331 58/pop-to-eax
21332
21333 89/<- %esp 5/r32/ebp
21334 5d/pop-to-ebp
21335 c3/return
21336
21337 $check-mu-return-stmt:error1:
21338 (write-buffered *(ebp+0x10) "fn ")
21339 8b/-> *(ebp+0xc) 0/r32/eax
21340 (lookup *eax *(eax+4))
21341 (write-buffered *(ebp+0x10) %eax)
21342 (write-buffered *(ebp+0x10) ": return: '")
21343 (lookup *edi *(edi+4))
21344 (lookup *eax *(eax+4))
21345 (write-buffered *(ebp+0x10) %eax)
21346 (write-buffered *(ebp+0x10) "' has the wrong type\n")
21347 (flush *(ebp+0x10))
21348 (stop *(ebp+0x14) 1)
21349
21350
21351 $check-mu-return-stmt:error2:
21352 (write-buffered *(ebp+0x10) "fn ")
21353 8b/-> *(ebp+0xc) 0/r32/eax
21354 (lookup *eax *(eax+4))
21355 (write-buffered *(ebp+0x10) %eax)
21356 (write-buffered *(ebp+0x10) ": return: '")
21357 (lookup *edi *(edi+4))
21358 (lookup *eax *(eax+4))
21359 (write-buffered *(ebp+0x10) %eax)
21360 (write-buffered *(ebp+0x10) "' is no longer available\n")
21361 (flush *(ebp+0x10))
21362 (stop *(ebp+0x14) 1)
21363
21364
21365 $check-mu-return-stmt:error-too-few-inouts:
21366 (write-buffered *(ebp+0x10) "fn ")
21367 8b/-> *(ebp+0xc) 0/r32/eax
21368 (lookup *eax *(eax+4))
21369 (write-buffered *(ebp+0x10) %eax)
21370 (write-buffered *(ebp+0x10) ": return: too few inouts\n")
21371 (flush *(ebp+0x10))
21372 (stop *(ebp+0x14) 1)
21373
21374
21375 $check-mu-return-stmt:error-too-many-inouts:
21376 (write-buffered *(ebp+0x10) "fn ")
21377 8b/-> *(ebp+0xc) 0/r32/eax
21378 (lookup *eax *(eax+4))
21379 (write-buffered *(ebp+0x10) %eax)
21380 (write-buffered *(ebp+0x10) ": return: too many inouts\n")
21381 (flush *(ebp+0x10))
21382 (stop *(ebp+0x14) 1)
21383
21384
21385 check-all-unique-registers:
21386
21387 55/push-ebp
21388 89/<- %ebp 4/r32/esp
21389
21390 50/push-eax
21391 51/push-ecx
21392 56/push-esi
21393
21394 81 5/subop/subtract %esp 0x60/imm32
21395 68/push 0x60/imm32/size
21396 68/push 0/imm32/read
21397 68/push 0/imm32/write
21398 89/<- %esi 4/r32/esp
21399
21400 8b/-> *(ebp+8) 1/r32/ecx
21401 {
21402
21403 81 7/subop/compare %ecx 0/imm32
21404 0f 84/jump-if-= break/disp32
21405
21406 (lookup *ecx *(ecx+4))
21407 (lookup *(eax+0x18) *(eax+0x1c))
21408
21409 (maybe-get %esi %eax 0xc)
21410 3d/compare-eax-and 0/imm32
21411 0f 85/jump-if-!= $check-all-unique-registers:abort/disp32
21412
21413 (lookup *ecx *(ecx+4))
21414 (lookup *(eax+0x18) *(eax+0x1c))
21415 (get-or-insert %esi %eax 0xc Heap)
21416
21417 (lookup *(ecx+8) *(ecx+0xc))
21418 89/<- %ecx 0/r32/eax
21419 e9/jump loop/disp32
21420 }
21421 $check-all-unique-registers:end:
21422
21423 81 0/subop/add %esp 0x6c/imm32
21424
21425 5e/pop-to-esi
21426 59/pop-to-ecx
21427 58/pop-to-eax
21428
21429 89/<- %esp 5/r32/ebp
21430 5d/pop-to-ebp
21431 c3/return
21432
21433 $check-all-unique-registers:abort:
21434 (write-buffered *(ebp+0x10) "fn ")
21435 8b/-> *(ebp+0xc) 0/r32/eax
21436 (lookup *eax *(eax+4))
21437 (write-buffered *(ebp+0x10) %eax)
21438 (write-buffered *(ebp+0x10) ": outputs must be in unique registers\n")
21439 (flush *(ebp+0x10))
21440 (stop *(ebp+0x14) 1)
21441
21442
21443
21444
21445
21446 register-within-list-with-conflict?:
21447
21448 55/push-ebp
21449 89/<- %ebp 4/r32/esp
21450
21451 51/push-ecx
21452 52/push-edx
21453 53/push-ebx
21454 56/push-esi
21455 57/push-edi
21456
21457 8b/-> *(ebp+8) 0/r32/eax
21458 (lookup *eax *(eax+4))
21459 (lookup *(eax+0x18) *(eax+0x1c))
21460
21461
21462
21463
21464
21465 3d/compare-eax-and 0/imm32
21466 0f 84/jump-if-= $register-within-list-with-conflict?:end/disp32
21467 89/<- %ebx 0/r32/eax
21468
21469 8b/-> *(ebp+0xc) 1/r32/ecx
21470
21471 8b/-> *(ebp+0x10) 2/r32/edx
21472 {
21473
21474 81 7/subop/compare %edi 0/imm32
21475 0f 84/jump-if-= break/disp32
21476
21477 39/compare %ecx 2/r32/edx
21478 0f 84/jump-if-= break/disp32
21479
21480 (lookup *ecx *(ecx+4))
21481 (lookup *(eax+0x18) *(eax+0x1c))
21482
21483 3d/compare-eax-and 0/imm32
21484 74/jump-if-= $register-within-list-with-conflict?:continue/disp8
21485
21486 (string-equal? %eax %ebx)
21487 3d/compare-eax-and 0/imm32/false
21488 {
21489 74/jump-if-= break/disp8
21490
21491
21492
21493 8b/-> *(ebp+0x14) 0/r32/eax
21494 (lookup *(eax+0xc) *(eax+0x10))
21495 (register-conflict? %ebx %eax *(ebp+0xc))
21496 eb/jump $register-within-list-with-conflict?:end/disp8
21497 }
21498 $register-within-list-with-conflict?:continue:
21499
21500 (lookup *(ecx+8) *(ecx+0xc))
21501 89/<- %ecx 0/r32/eax
21502 e9/jump loop/disp32
21503 }
21504
21505 b8/copy-to-eax 0/imm32/false
21506 $register-within-list-with-conflict?:end:
21507
21508 5f/pop-to-edi
21509 5e/pop-to-esi
21510 5b/pop-to-ebx
21511 5a/pop-to-edx
21512 59/pop-to-ecx
21513
21514 89/<- %esp 5/r32/ebp
21515 5d/pop-to-ebp
21516 c3/return
21517
21518
21519
21520
21521
21522 register-conflict?:
21523
21524 55/push-ebp
21525 89/<- %ebp 4/r32/esp
21526
21527 51/push-ecx
21528 52/push-edx
21529 53/push-ebx
21530 56/push-esi
21531 57/push-edi
21532
21533
21534
21535
21536
21537 8b/-> *(ebp+0x10) 7/r32/edi
21538
21539 8b/-> *(ebp+0xc) 6/r32/esi
21540 {
21541
21542 81 7/subop/compare %edi 0/imm32
21543 0f 84/jump-if-= break/disp32
21544
21545 (lookup *edi *(edi+4))
21546 (lookup *(eax+0x18) *(eax+0x1c))
21547 (string-equal? %eax *(ebp+8))
21548 3d/compare-eax-and 0/imm32/false
21549 0f 84/jump-if= $register-conflict?:continue/disp32
21550
21551
21552
21553 (lookup *esi *(esi+4))
21554 (lookup *(eax+0x18) *(eax+0x1c))
21555
21556 3d/compare-eax-and 0/imm32
21557 {
21558 75/jump-if-!= break/disp8
21559
21560
21561 b8/copy-to-eax 1/imm32/true
21562 e9/jump $register-conflict?:end/disp32
21563 }
21564
21565 (string-equal? %eax *(ebp+8))
21566 3d/compare-eax-and 0/imm32/false
21567 0f 94/set-if-= %al
21568
21569
21570
21571
21572 eb/jump $register-conflict?:end/disp8
21573 $register-conflict?:continue:
21574
21575 (lookup *(edi+8) *(edi+0xc))
21576 89/<- %edi 0/r32/eax
21577
21578 (lookup *(esi+8) *(esi+0xc))
21579 89/<- %esi 0/r32/eax
21580 e9/jump loop/disp32
21581 }
21582
21583 (write-buffered Stderr "register-conflict? misused\n")
21584 (flush Stderr)
21585 e8/call syscall_exit/disp32
21586 $register-conflict?:end:
21587
21588 5f/pop-to-edi
21589 5e/pop-to-esi
21590 5b/pop-to-ebx
21591 5a/pop-to-edx
21592 59/pop-to-ecx
21593
21594 89/<- %esp 5/r32/ebp
21595 5d/pop-to-ebp
21596 c3/return
21597
21598 check-final-stmt-is-return:
21599
21600 55/push-ebp
21601 89/<- %ebp 4/r32/esp
21602
21603 50/push-eax
21604 51/push-ecx
21605
21606 8b/-> *(ebp+8) 0/r32/eax
21607 (lookup *(eax+4) *(eax+8))
21608 3d/compare-eax-and 0/imm32
21609 74/jump-if-= $check-final-stmt-is-return:end/disp8
21610 89/<- %ecx 0/r32/eax
21611 {
21612
21613 (lookup *(ecx+8) *(ecx+0xc))
21614 3d/compare-eax-and 0/imm32
21615 74/jump-if-= break/disp8
21616
21617 89/<- %ecx 0/r32/eax
21618 e9/jump loop/disp32
21619 }
21620 $check-final-stmt-is-return:check-tag:
21621
21622 (lookup *ecx *(ecx+4))
21623 81 7/subop/compare *eax 1/imm32/stmt1
21624 75/jump-if-!= $check-final-stmt-is-return:error/disp8
21625 $check-final-stmt-is-return:check-operation:
21626
21627 (lookup *(eax+4) *(eax+8))
21628 (string-equal? %eax "return")
21629 3d/compare-eax-and 0/imm32/false
21630 74/jump-if-= $check-final-stmt-is-return:error/disp8
21631 $check-final-stmt-is-return:end:
21632
21633 59/pop-to-ecx
21634 58/pop-to-eax
21635
21636 89/<- %esp 5/r32/ebp
21637 5d/pop-to-ebp
21638 c3/return
21639
21640 $check-final-stmt-is-return:error:
21641 (write-buffered *(ebp+0x10) "fn ")
21642 8b/-> *(ebp+0xc) 0/r32/eax
21643 (lookup *eax *(eax+4))
21644 (write-buffered *(ebp+0x10) %eax)
21645 (write-buffered *(ebp+0x10) ": final statement should be a 'return'\n")
21646 (flush *(ebp+0x10))
21647 (stop *(ebp+0x14) 1)
21648
21649
21650 check-no-breaks:
21651
21652 55/push-ebp
21653 89/<- %ebp 4/r32/esp
21654
21655 50/push-eax
21656 51/push-ecx
21657
21658 8b/-> *(ebp+8) 0/r32/eax
21659 (lookup *(eax+4) *(eax+8))
21660 3d/compare-eax-and 0/imm32
21661 0f 84/jump-if-= $check-no-breaks:end/disp32
21662 89/<- %ecx 0/r32/eax
21663 {
21664
21665 (lookup *(ecx+8) *(ecx+0xc))
21666 3d/compare-eax-and 0/imm32
21667 74/jump-if-= break/disp8
21668
21669 (lookup *ecx *(ecx+4))
21670 81 7/subop/compare *eax 1/imm32/stmt1
21671 75/jump-if-!= $check-no-breaks:continue/disp8
21672
21673 (lookup *(eax+4) *(eax+8))
21674 (string-starts-with? %eax "break")
21675 3d/compare-eax-and 0/imm32/false
21676 75/jump-if-!= $check-no-breaks:error/disp8
21677 $check-no-breaks:continue:
21678
21679 (lookup *(ecx+8) *(ecx+0xc))
21680 89/<- %ecx 0/r32/eax
21681 e9/jump loop/disp32
21682 }
21683 $check-no-breaks:end:
21684
21685 59/pop-to-ecx
21686 58/pop-to-eax
21687
21688 89/<- %esp 5/r32/ebp
21689 5d/pop-to-ebp
21690 c3/return
21691
21692 $check-no-breaks:error:
21693 (write-buffered *(ebp+0x10) "fn ")
21694 8b/-> *(ebp+0xc) 0/r32/eax
21695 (lookup *eax *(eax+4))
21696 (write-buffered *(ebp+0x10) %eax)
21697 (write-buffered *(ebp+0x10) " has outputs, so you cannot 'break' out of the outermost block. Use 'return'.\n")
21698 (flush *(ebp+0x10))
21699 (stop *(ebp+0x14) 1)
21700
21701
21702 check-mu-get-stmt:
21703
21704 55/push-ebp
21705 89/<- %ebp 4/r32/esp
21706
21707 50/push-eax
21708 51/push-ecx
21709 52/push-edx
21710 53/push-ebx
21711 56/push-esi
21712 57/push-edi
21713
21714 8b/-> *(ebp+8) 6/r32/esi
21715
21716
21717 (lookup *(esi+0xc) *(esi+0x10))
21718 3d/compare-eax-and 0/imm32/false
21719 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-inouts/disp32
21720 (lookup *eax *(eax+4))
21721 89/<- %ecx 0/r32/eax
21722 $check-mu-get-stmt:check-base:
21723
21724
21725
21726 (lookup *(ecx+8) *(ecx+0xc))
21727 89/<- %ebx 0/r32/eax
21728 {
21729 81 7/subop/compare *ebx 0/imm32/false
21730 0f 85/jump-if-!= break/disp32
21731 $check-mu-get-stmt:base-is-compound:
21732
21733 (lookup *(ebx+4) *(ebx+8))
21734 (is-simple-mu-type? %eax 2)
21735 3d/compare-eax-and 0/imm32/false
21736 74/jump-if-= break/disp8
21737 $check-mu-get-stmt:base-is-addr:
21738
21739 81 7/subop/compare *(ecx+0x18) 0/imm32
21740 0f 84/jump-if-= $check-mu-get-stmt:error-base-type-addr-but-not-register/disp32
21741 $check-mu-get-stmt:base-is-addr-in-register:
21742
21743 (lookup *(ebx+0xc) *(ebx+0x10))
21744 81 7/subop/compare *(eax+0xc) 0/imm32
21745 0f 85/jump-if-!= $check-mu-get-stmt:error-bad-base/disp32
21746 $check-mu-get-stmt:base-is-addr-to-atom-in-register:
21747 (lookup *(eax+4) *(eax+8))
21748 89/<- %ebx 0/r32/eax
21749 }
21750 $check-mu-get-stmt:check-base-typeinfo:
21751
21752 81 7/subop/compare *ebx 0/imm32/false
21753 {
21754 75/jump-if-!= break/disp8
21755 (lookup *(ebx+4) *(ebx+8))
21756 89/<- %ebx 0/r32/eax
21757 }
21758
21759 8b/-> *(ebx+4) 3/r32/ebx
21760 (is-container? %ebx)
21761 3d/compare-eax-and 0/imm32/false
21762 0f 84/jump-if-= $check-mu-get-stmt:error-bad-base/disp32
21763
21764
21765 68/push 0/imm32
21766 68/push 0/imm32
21767 89/<- %ecx 4/r32/esp
21768
21769 (find-typeinfo %ebx %ecx)
21770 (lookup *ecx *(ecx+4))
21771
21772 81 0/subop/add %esp 8/imm32
21773
21774 89/<- %edx 0/r32/eax
21775
21776 (lookup *(esi+0xc) *(esi+0x10))
21777 (lookup *(eax+8) *(eax+0xc))
21778 89/<- %ecx 0/r32/eax
21779
21780 3d/compare-eax-and 0/imm32/false
21781 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-inouts/disp32
21782
21783 (lookup *ecx *(ecx+4))
21784 89/<- %ecx 0/r32/eax
21785
21786 81 7/subop/compare *(ecx+0x14) -1/imm32/uninitialized
21787 0f 84/jump-if-= $check-mu-get-stmt:error-bad-field/disp32
21788
21789 (lookup *(esi+0xc) *(esi+0x10))
21790 (lookup *(eax+8) *(eax+0xc))
21791 (lookup *(eax+8) *(eax+0xc))
21792 3d/compare-eax-and 0/imm32/false
21793 0f 85/jump-if-!= $check-mu-get-stmt:error-too-many-inouts/disp32
21794
21795 (lookup *(esi+0x14) *(esi+0x18))
21796
21797 3d/compare-eax-and 0/imm32/false
21798 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-outputs/disp32
21799 (lookup *eax *(eax+4))
21800 89/<- %edi 0/r32/eax
21801 $check-mu-get-stmt:check-output-type:
21802
21803
21804 (lookup *(edi+0x18) *(edi+0x1c))
21805 3d/compare-eax-and 0/imm32
21806 0f 84/jump-if-= $check-mu-get-stmt:error-output-not-in-register/disp32
21807
21808 (lookup *(edi+8) *(edi+0xc))
21809 81 7/subop/compare *eax 0/imm32/false
21810 0f 85/jump-if-!= $check-mu-get-stmt:error-output-type-not-address/disp32
21811
21812 (lookup *(eax+4) *(eax+8))
21813 (is-simple-mu-type? %eax 2)
21814 3d/compare-eax-and 0/imm32/false
21815 0f 84/jump-if-= $check-mu-get-stmt:error-output-type-not-address/disp32
21816 $check-mu-get-stmt:check-output-type-match:
21817
21818 (lookup *(edi+8) *(edi+0xc))
21819 (lookup *(eax+0xc) *(eax+0x10))
21820
21821 81 7/subop/compare *(eax+0xc) 0/imm32/null
21822 {
21823 75/jump-if-!= break/disp8
21824 (lookup *(eax+4) *(eax+8))
21825 }
21826 89/<- %edi 0/r32/eax
21827
21828 (lookup *ecx *(ecx+4))
21829 89/<- %ecx 0/r32/eax
21830
21831 (lookup *(edx+4) *(edx+8))
21832 (get %eax %ecx 0x10)
21833
21834 (lookup *eax *(eax+4))
21835 (lookup *eax *(eax+4))
21836 (lookup *(eax+8) *(eax+0xc))
21837
21838 (type-equal? %edi %eax)
21839 3d/compare-eax-and 0/imm32/false
21840 0f 84/jump-if-= $check-mu-get-stmt:error-bad-output-type/disp32
21841
21842 (lookup *(esi+0x14) *(esi+0x18))
21843 (lookup *(eax+8) *(eax+0xc))
21844 3d/compare-eax-and 0/imm32/false
21845 0f 85/jump-if-!= $check-mu-get-stmt:error-too-many-outputs/disp32
21846 $check-mu-get-stmt:end:
21847
21848 5f/pop-to-edi
21849 5e/pop-to-esi
21850 5b/pop-to-ebx
21851 5a/pop-to-edx
21852 59/pop-to-ecx
21853 58/pop-to-eax
21854
21855 89/<- %esp 5/r32/ebp
21856 5d/pop-to-ebp
21857 c3/return
21858
21859 $check-mu-get-stmt:error-too-few-inouts:
21860 (write-buffered *(ebp+0x10) "fn ")
21861 8b/-> *(ebp+0xc) 0/r32/eax
21862 (lookup *eax *(eax+4))
21863 (write-buffered *(ebp+0x10) %eax)
21864 (write-buffered *(ebp+0x10) ": stmt get: too few inouts (2 required)\n")
21865 (flush *(ebp+0x10))
21866 (stop *(ebp+0x14) 1)
21867
21868
21869 $check-mu-get-stmt:error-too-many-inouts:
21870 (write-buffered *(ebp+0x10) "fn ")
21871 8b/-> *(ebp+0xc) 0/r32/eax
21872 (lookup *eax *(eax+4))
21873 (write-buffered *(ebp+0x10) %eax)
21874 (write-buffered *(ebp+0x10) ": stmt get: too many inouts (2 required)\n")
21875 (flush *(ebp+0x10))
21876 (stop *(ebp+0x14) 1)
21877
21878
21879 $check-mu-get-stmt:error-too-few-outputs:
21880 (write-buffered *(ebp+0x10) "fn ")
21881 8b/-> *(ebp+0xc) 0/r32/eax
21882 (lookup *eax *(eax+4))
21883 (write-buffered *(ebp+0x10) %eax)
21884 (write-buffered *(ebp+0x10) ": stmt get: must have an output\n")
21885 (flush *(ebp+0x10))
21886 (stop *(ebp+0x14) 1)
21887
21888
21889 $check-mu-get-stmt:error-too-many-outputs:
21890 (write-buffered *(ebp+0x10) "fn ")
21891 8b/-> *(ebp+0xc) 0/r32/eax
21892 (lookup *eax *(eax+4))
21893 (write-buffered *(ebp+0x10) %eax)
21894 (write-buffered *(ebp+0x10) ": stmt get: too many outputs (1 required)\n")
21895 (flush *(ebp+0x10))
21896 (stop *(ebp+0x14) 1)
21897
21898
21899 $check-mu-get-stmt:error-bad-base:
21900
21901 (write-buffered *(ebp+0x10) "fn ")
21902 8b/-> *(ebp+0xc) 0/r32/eax
21903 (lookup *eax *(eax+4))
21904 (write-buffered *(ebp+0x10) %eax)
21905 (write-buffered *(ebp+0x10) ": stmt get: var '")
21906 (lookup *(esi+0xc) *(esi+0x10))
21907 (lookup *eax *(eax+4))
21908 (lookup *eax *(eax+4))
21909 (write-buffered *(ebp+0x10) %eax)
21910 (write-buffered *(ebp+0x10) "' must have a 'type' definition\n")
21911 (flush *(ebp+0x10))
21912 (stop *(ebp+0x14) 1)
21913
21914
21915 $check-mu-get-stmt:error-base-type-addr-but-not-register:
21916 (write-buffered *(ebp+0x10) "fn ")
21917 8b/-> *(ebp+0xc) 0/r32/eax
21918 (lookup *eax *(eax+4))
21919 (write-buffered *(ebp+0x10) %eax)
21920 (write-buffered *(ebp+0x10) ": stmt get: var '")
21921 (lookup *(esi+0xc) *(esi+0x10))
21922 (lookup *eax *(eax+4))
21923 (lookup *eax *(eax+4))
21924 (write-buffered *(ebp+0x10) %eax)
21925 (write-buffered *(ebp+0x10) "' is an 'addr' type, and so must live in a register\n")
21926 (flush *(ebp+0x10))
21927 (stop *(ebp+0x14) 1)
21928
21929
21930 $check-mu-get-stmt:error-bad-field:
21931
21932 (write-buffered *(ebp+0x10) "fn ")
21933 8b/-> *(ebp+0xc) 0/r32/eax
21934 (lookup *eax *(eax+4))
21935 (write-buffered *(ebp+0x10) %eax)
21936 (write-buffered *(ebp+0x10) ": stmt get: type '")
21937
21938 bf/copy-to-edi Type-id/imm32
21939 8b/-> *(edi+ebx<<2+0xc) 6/r32/esi
21940 {
21941 81 7/subop/compare %esi 0/imm32
21942 74/jump-if-= break/disp8
21943 (write-buffered *(ebp+0x10) %esi)
21944 }
21945
21946 (write-buffered *(ebp+0x10) "' has no member called '")
21947 (lookup *ecx *(ecx+4))
21948 (write-buffered *(ebp+0x10) %eax)
21949 (write-buffered *(ebp+0x10) "'\n")
21950 (flush *(ebp+0x10))
21951 (stop *(ebp+0x14) 1)
21952
21953
21954 $check-mu-get-stmt:error-output-not-in-register:
21955 (write-buffered *(ebp+0x10) "fn ")
21956 8b/-> *(ebp+0xc) 0/r32/eax
21957 (lookup *eax *(eax+4))
21958 (write-buffered *(ebp+0x10) %eax)
21959 (write-buffered *(ebp+0x10) ": stmt get: output '")
21960 (lookup *edi *(edi+4))
21961 (write-buffered *(ebp+0x10) %eax)
21962 (write-buffered *(ebp+0x10) "' is not in a register\n")
21963 (flush *(ebp+0x10))
21964 (stop *(ebp+0x14) 1)
21965
21966
21967 $check-mu-get-stmt:error-output-type-not-address:
21968 (write-buffered *(ebp+0x10) "fn ")
21969 8b/-> *(ebp+0xc) 0/r32/eax
21970 (lookup *eax *(eax+4))
21971 (write-buffered *(ebp+0x10) %eax)
21972 (write-buffered *(ebp+0x10) ": stmt get: output must be an addr\n")
21973 (flush *(ebp+0x10))
21974 (stop *(ebp+0x14) 1)
21975
21976
21977 $check-mu-get-stmt:error-bad-output-type:
21978 (write-buffered *(ebp+0x10) "fn ")
21979 8b/-> *(ebp+0xc) 0/r32/eax
21980 (lookup *eax *(eax+4))
21981 (write-buffered *(ebp+0x10) %eax)
21982 (write-buffered *(ebp+0x10) ": stmt get: wrong output type for member '")
21983 (write-buffered *(ebp+0x10) %ecx)
21984 (write-buffered *(ebp+0x10) "' of type '")
21985 bf/copy-to-edi Type-id/imm32
21986 8b/-> *(edi+ebx<<2+0xc) 6/r32/esi
21987 {
21988 81 7/subop/compare %esi 0/imm32
21989 74/jump-if-= break/disp8
21990 (write-buffered *(ebp+0x10) %esi)
21991 }
21992 (write-buffered *(ebp+0x10) "'\n")
21993 (flush *(ebp+0x10))
21994 (stop *(ebp+0x14) 1)
21995
21996
21997 check-mu-index-stmt:
21998
21999 55/push-ebp
22000 89/<- %ebp 4/r32/esp
22001
22002 50/push-eax
22003 51/push-ecx
22004 52/push-edx
22005 53/push-ebx
22006 56/push-esi
22007 57/push-edi
22008
22009 8b/-> *(ebp+8) 6/r32/esi
22010
22011
22012 (lookup *(esi+0xc) *(esi+0x10))
22013 $check-mu-index-stmt:check-no-inouts:
22014 3d/compare-eax-and 0/imm32
22015 0f 84/jump-if-= $check-mu-index-stmt:error-too-few-inouts/disp32
22016 (lookup *eax *(eax+4))
22017 89/<- %ecx 0/r32/eax
22018
22019
22020 (lookup *(ecx+8) *(ecx+0xc))
22021 89/<- %ebx 0/r32/eax
22022
22023 81 7/subop/compare *ebx 0/imm32/false
22024 {
22025 74/jump-if-= break/disp8
22026 (is-simple-mu-type? %ebx 3)
22027 3d/compare-eax-and 0/imm32/false
22028 0f 85/jump-if-!= $check-mu-index-stmt:error-base-array-atom-type/disp32
22029 0f 84/jump-if-= $check-mu-index-stmt:error-base-non-array-type/disp32
22030 }
22031 $check-mu-index-stmt:base-is-compound:
22032
22033 {
22034 (lookup *(ebx+4) *(ebx+8))
22035 (is-simple-mu-type? %eax 2)
22036 3d/compare-eax-and 0/imm32/false
22037 75/jump-if-!= break/disp8
22038 (lookup *(ebx+4) *(ebx+8))
22039 (is-simple-mu-type? %eax 3)
22040 3d/compare-eax-and 0/imm32/false
22041 75/jump-if-!= break/disp8
22042 e9/jump $check-mu-index-stmt:error-base-non-array-type/disp32
22043 }
22044
22045 {
22046 (lookup *(ebx+4) *(ebx+8))
22047 (is-simple-mu-type? %eax 2)
22048 3d/compare-eax-and 0/imm32/false
22049 74/jump-if-= break/disp8
22050 $check-mu-index-stmt:base-is-addr:
22051 (lookup *(ebx+0xc) *(ebx+0x10))
22052 (lookup *(eax+4) *(eax+8))
22053 (is-simple-mu-type? %eax 3)
22054 3d/compare-eax-and 0/imm32/false
22055 0f 84/jump-if-= $check-mu-index-stmt:error-base-non-array-type/disp32
22056 $check-mu-index-stmt:check-base-addr-is-register:
22057 81 7/subop/compare *(ecx+0x18) 0/imm32
22058 0f 84/jump-if-= $check-mu-index-stmt:error-base-address-array-type-on-stack/disp32
22059 }
22060
22061 {
22062 (lookup *(ebx+4) *(ebx+8))
22063 (is-simple-mu-type? %eax 3)
22064 3d/compare-eax-and 0/imm32/false
22065 74/jump-if-= break/disp8
22066 $check-mu-index-stmt:base-is-array:
22067 81 7/subop/compare *(ecx+0x18) 0/imm32
22068 0f 85/jump-if-!= $check-mu-index-stmt:error-base-array-type-in-register/disp32
22069 }
22070
22071 {
22072 (lookup *(ebx+4) *(ebx+8))
22073 (is-simple-mu-type? %eax 2)
22074 3d/compare-eax-and 0/imm32/false
22075 74/jump-if-= break/disp8
22076 (lookup *(ebx+0xc) *(ebx+0x10))
22077 89/<- %ebx 0/r32/eax
22078 }
22079
22080
22081 (lookup *(esi+0xc) *(esi+0x10))
22082 (lookup *(eax+8) *(eax+0xc))
22083 $check-mu-index-stmt:check-single-inout:
22084 3d/compare-eax-and 0/imm32
22085 0f 84/jump-if-= $check-mu-index-stmt:error-too-few-inouts/disp32
22086 (lookup *eax *(eax+4))
22087 89/<- %ecx 0/r32/eax
22088
22089
22090 (lookup *(ecx+8) *(ecx+0xc))
22091 89/<- %edx 0/r32/eax
22092
22093 81 7/subop/compare *edx 0/imm32/false
22094 {
22095 74/jump-if-= break/disp8
22096 $check-mu-index-stmt:index-type-is-atom:
22097 (is-simple-mu-type? %edx 0)
22098 3d/compare-eax-and 0/imm32/false
22099 75/jump-if-!= $check-mu-index-stmt:index-type-done/disp8
22100 (is-simple-mu-type? %edx 1)
22101 3d/compare-eax-and 0/imm32/false
22102 75/jump-if-!= $check-mu-index-stmt:index-type-done/disp8
22103 (is-simple-mu-type? %edx 7)
22104 3d/compare-eax-and 0/imm32/false
22105 0f 85/jump-if-!= $check-mu-index-stmt:error-index-offset-atom-type/disp32
22106 e9/jump $check-mu-index-stmt:error-invalid-index-type/disp32
22107 }
22108
22109 {
22110 75/jump-if-!= break/disp8
22111 $check-mu-index-stmt:index-type-is-non-atom:
22112 (lookup *(edx+4) *(edx+8))
22113 (is-simple-mu-type? %eax 7)
22114 3d/compare-eax-and 0/imm32/false
22115 0f 84/jump-if-= $check-mu-index-stmt:error-invalid-index-type/disp32
22116 }
22117 $check-mu-index-stmt:index-type-done:
22118
22119 {
22120 (is-simple-mu-type? %edx 0)
22121 3d/compare-eax-and 0/imm32/false
22122 75/jump-if-!= break/disp8
22123 $check-mu-index-stmt:check-index-in-register:
22124 81 7/subop/compare *(ecx+0x18) 0/imm32
22125 0f 84/jump-if-= $check-mu-index-stmt:error-index-on-stack/disp32
22126 }
22127
22128 {
22129 (is-simple-mu-type? %edx 1)
22130 3d/compare-eax-and 0/imm32/false
22131 74/jump-if-= break/disp8
22132 $check-mu-index-stmt:check-index-can-be-int:
22133 (lookup *(esi+0xc) *(esi+0x10))
22134 (lookup *eax *(eax+4))
22135 (array-element-size %eax)
22136 3d/compare-eax-and 1/imm32
22137 74/jump-if-= break/disp8
22138 3d/compare-eax-and 2/imm32
22139 74/jump-if-= break/disp8
22140 3d/compare-eax-and 4/imm32
22141 74/jump-if-= break/disp8
22142 3d/compare-eax-and 8/imm32
22143 74/jump-if-= break/disp8
22144 e9/jump $check-mu-index-stmt:error-index-needs-offset/disp32
22145 }
22146
22147 (lookup *(esi+0xc) *(esi+0x10))
22148 (lookup *(eax+8) *(eax+0xc))
22149 (lookup *(eax+8) *(eax+0xc))
22150 3d/compare-eax-and 0/imm32/false
22151 0f 85/jump-if-!= $check-mu-index-stmt:error-too-many-inouts/disp32
22152
22153
22154 (lookup *(esi+0x14) *(esi+0x18))
22155 3d/compare-eax-and 0/imm32/false
22156 0f 84/jump-if-= $check-mu-index-stmt:error-too-few-outputs/disp32
22157 (lookup *eax *(eax+4))
22158 89/<- %edi 0/r32/eax
22159
22160
22161 (lookup *(edi+8) *(edi+0xc))
22162 89/<- %edx 0/r32/eax
22163 81 7/subop/compare *edx 0/imm32/false
22164 0f 85/jump-if-!= $check-mu-index-stmt:error-output-type-not-address/disp32
22165
22166 (lookup *(edx+4) *(edx+8))
22167 (is-simple-mu-type? %eax 2)
22168 3d/compare-eax-and 0/imm32/false
22169 0f 84/jump-if-= $check-mu-index-stmt:error-output-type-not-address/disp32
22170
22171 (type-tail %ebx)
22172 89/<- %ebx 0/r32/eax
22173 (type-tail %edx)
22174 (type-equal? %ebx %eax)
22175 3d/compare-eax-and 0/imm32/false
22176 0f 84/jump-if-= $check-mu-index-stmt:error-bad-output-type/disp32
22177
22178 (lookup *(esi+0x14) *(esi+0x18))
22179 (lookup *(eax+8) *(eax+0xc))
22180 3d/compare-eax-and 0/imm32/false
22181 0f 85/jump-if-!= $check-mu-index-stmt:error-too-many-outputs/disp32
22182 $check-mu-index-stmt:end:
22183
22184 5f/pop-to-edi
22185 5e/pop-to-esi
22186 5b/pop-to-ebx
22187 5a/pop-to-edx
22188 59/pop-to-ecx
22189 58/pop-to-eax
22190
22191 89/<- %esp 5/r32/ebp
22192 5d/pop-to-ebp
22193 c3/return
22194
22195 $check-mu-index-stmt:error-base-non-array-type:
22196 (write-buffered *(ebp+0x10) "fn ")
22197 8b/-> *(ebp+0xc) 0/r32/eax
22198 (lookup *eax *(eax+4))
22199 (write-buffered *(ebp+0x10) %eax)
22200 (write-buffered *(ebp+0x10) ": stmt index: var '")
22201 (lookup *ecx *(ecx+4))
22202 (write-buffered *(ebp+0x10) %eax)
22203 (write-buffered *(ebp+0x10) "' is not an array\n")
22204 (flush *(ebp+0x10))
22205 (stop *(ebp+0x14) 1)
22206
22207
22208 $check-mu-index-stmt:error-base-array-atom-type:
22209 (write-buffered *(ebp+0x10) "fn ")
22210 8b/-> *(ebp+0xc) 0/r32/eax
22211 (lookup *eax *(eax+4))
22212 (write-buffered *(ebp+0x10) %eax)
22213 (write-buffered *(ebp+0x10) ": stmt index: array '")
22214 (lookup *ecx *(ecx+4))
22215 (write-buffered *(ebp+0x10) %eax)
22216 (write-buffered *(ebp+0x10) "' must specify the type of its elements\n")
22217 (flush *(ebp+0x10))
22218 (stop *(ebp+0x14) 1)
22219
22220
22221 $check-mu-index-stmt:error-base-address-array-type-on-stack:
22222 (write-buffered *(ebp+0x10) "fn ")
22223 8b/-> *(ebp+0xc) 0/r32/eax
22224 (lookup *eax *(eax+4))
22225 (write-buffered *(ebp+0x10) %eax)
22226 (write-buffered *(ebp+0x10) ": stmt index: var '")
22227 (lookup *ecx *(ecx+4))
22228 (write-buffered *(ebp+0x10) %eax)
22229 (write-buffered *(ebp+0x10) "' is an addr to an array, and so must live in a register\n")
22230 (flush *(ebp+0x10))
22231 (stop *(ebp+0x14) 1)
22232
22233
22234 $check-mu-index-stmt:error-base-array-type-in-register:
22235 (write-buffered *(ebp+0x10) "fn ")
22236 8b/-> *(ebp+0xc) 0/r32/eax
22237 (lookup *eax *(eax+4))
22238 (write-buffered *(ebp+0x10) %eax)
22239 (write-buffered *(ebp+0x10) ": stmt index: var '")
22240 (lookup *ecx *(ecx+4))
22241 (write-buffered *(ebp+0x10) %eax)
22242 (write-buffered *(ebp+0x10) "' is an array, and so must live on the stack\n")
22243 (flush *(ebp+0x10))
22244 (stop *(ebp+0x14) 1)
22245
22246
22247 $check-mu-index-stmt:error-too-few-inouts:
22248 (write-buffered *(ebp+0x10) "fn ")
22249 8b/-> *(ebp+0xc) 0/r32/eax
22250 (lookup *eax *(eax+4))
22251 (write-buffered *(ebp+0x10) %eax)
22252 (write-buffered *(ebp+0x10) ": stmt index: too few inouts (2 required)\n")
22253 (flush *(ebp+0x10))
22254 (stop *(ebp+0x14) 1)
22255
22256
22257 $check-mu-index-stmt:error-invalid-index-type:
22258 (write-buffered *(ebp+0x10) "fn ")
22259 8b/-> *(ebp+0xc) 0/r32/eax
22260 (lookup *eax *(eax+4))
22261 (write-buffered *(ebp+0x10) %eax)
22262 (write-buffered *(ebp+0x10) ": stmt index: second argument '")
22263 (lookup *ecx *(ecx+4))
22264 (write-buffered *(ebp+0x10) %eax)
22265 (write-buffered *(ebp+0x10) "' must be an int or offset\n")
22266 (flush *(ebp+0x10))
22267 (stop *(ebp+0x14) 1)
22268
22269
22270 $check-mu-index-stmt:error-index-offset-atom-type:
22271 (write-buffered *(ebp+0x10) "fn ")
22272 8b/-> *(ebp+0xc) 0/r32/eax
22273 (lookup *eax *(eax+4))
22274 (write-buffered *(ebp+0x10) %eax)
22275 (write-buffered *(ebp+0x10) ": stmt index: offset '")
22276 (lookup *ecx *(ecx+4))
22277 (write-buffered *(ebp+0x10) %eax)
22278 (write-buffered *(ebp+0x10) "' must specify the type of array elements\n")
22279 (flush *(ebp+0x10))
22280 (stop *(ebp+0x14) 1)
22281
22282
22283 $check-mu-index-stmt:error-index-on-stack:
22284 (write-buffered *(ebp+0x10) "fn ")
22285 8b/-> *(ebp+0xc) 0/r32/eax
22286 (lookup *eax *(eax+4))
22287 (write-buffered *(ebp+0x10) %eax)
22288 (write-buffered *(ebp+0x10) ": stmt index: second argument '")
22289 (lookup *ecx *(ecx+4))
22290 (write-buffered *(ebp+0x10) %eax)
22291 (write-buffered *(ebp+0x10) "' must be in a register\n")
22292 (flush *(ebp+0x10))
22293 (stop *(ebp+0x14) 1)
22294
22295
22296 $check-mu-index-stmt:error-index-needs-offset:
22297 (write-buffered *(ebp+0x10) "fn ")
22298 8b/-> *(ebp+0xc) 0/r32/eax
22299 (lookup *eax *(eax+4))
22300 (write-buffered *(ebp+0x10) %eax)
22301 (write-buffered *(ebp+0x10) ": stmt index: cannot take an int for array '")
22302 (lookup *(esi+0xc) *(esi+0x10))
22303 (lookup *eax *(eax+4))
22304 (lookup *eax *(eax+4))
22305 (write-buffered *(ebp+0x10) %eax)
22306 (write-buffered *(ebp+0x10) "'; create an offset instead. See mu.md for details.\n")
22307 (flush *(ebp+0x10))
22308 (stop *(ebp+0x14) 1)
22309
22310
22311 $check-mu-index-stmt:error-too-many-inouts:
22312 (write-buffered *(ebp+0x10) "fn ")
22313 8b/-> *(ebp+0xc) 0/r32/eax
22314 (lookup *eax *(eax+4))
22315 (write-buffered *(ebp+0x10) %eax)
22316 (write-buffered *(ebp+0x10) ": stmt index: too many inouts (2 required)\n")
22317 (flush *(ebp+0x10))
22318 (stop *(ebp+0x14) 1)
22319
22320
22321 $check-mu-index-stmt:error-too-few-outputs:
22322 (write-buffered *(ebp+0x10) "fn ")
22323 8b/-> *(ebp+0xc) 0/r32/eax
22324 (lookup *eax *(eax+4))
22325 (write-buffered *(ebp+0x10) %eax)
22326 (write-buffered *(ebp+0x10) ": stmt index: must have an output\n")
22327 (flush *(ebp+0x10))
22328 (stop *(ebp+0x14) 1)
22329
22330
22331 $check-mu-index-stmt:error-too-many-outputs:
22332 (write-buffered *(ebp+0x10) "fn ")
22333 8b/-> *(ebp+0xc) 0/r32/eax
22334 (lookup *eax *(eax+4))
22335 (write-buffered *(ebp+0x10) %eax)
22336 (write-buffered *(ebp+0x10) ": stmt index: too many outputs (1 required)\n")
22337 (flush *(ebp+0x10))
22338 (stop *(ebp+0x14) 1)
22339
22340
22341 $check-mu-index-stmt:error-output-not-in-register:
22342 (write-buffered *(ebp+0x10) "fn ")
22343 8b/-> *(ebp+0xc) 0/r32/eax
22344 (lookup *eax *(eax+4))
22345 (write-buffered *(ebp+0x10) %eax)
22346 (write-buffered *(ebp+0x10) ": stmt index: output '")
22347 (lookup *edi *(edi+4))
22348 (write-buffered *(ebp+0x10) %eax)
22349 (write-buffered *(ebp+0x10) "' is not in a register\n")
22350 (flush *(ebp+0x10))
22351 (stop *(ebp+0x14) 1)
22352
22353
22354 $check-mu-index-stmt:error-output-type-not-address:
22355 (write-buffered *(ebp+0x10) "fn ")
22356 8b/-> *(ebp+0xc) 0/r32/eax
22357 (lookup *eax *(eax+4))
22358 (write-buffered *(ebp+0x10) %eax)
22359 (write-buffered *(ebp+0x10) ": stmt index: output '")
22360 (lookup *edi *(edi+4))
22361 (write-buffered *(ebp+0x10) %eax)
22362 (write-buffered *(ebp+0x10) "' must be an addr\n")
22363 (flush *(ebp+0x10))
22364 (stop *(ebp+0x14) 1)
22365
22366
22367 $check-mu-index-stmt:error-bad-output-type:
22368 (write-buffered *(ebp+0x10) "fn ")
22369 8b/-> *(ebp+0xc) 0/r32/eax
22370 (lookup *eax *(eax+4))
22371 (write-buffered *(ebp+0x10) %eax)
22372 (write-buffered *(ebp+0x10) ": stmt index: output '")
22373 (lookup *edi *(edi+4))
22374 (write-buffered *(ebp+0x10) %eax)
22375 (write-buffered *(ebp+0x10) "' does not have the right type\n")
22376 (flush *(ebp+0x10))
22377 (stop *(ebp+0x14) 1)
22378
22379
22380 check-mu-length-stmt:
22381
22382 55/push-ebp
22383 89/<- %ebp 4/r32/esp
22384
22385 50/push-eax
22386 51/push-ecx
22387 52/push-edx
22388 53/push-ebx
22389 56/push-esi
22390 57/push-edi
22391
22392 8b/-> *(ebp+8) 6/r32/esi
22393
22394
22395 (lookup *(esi+0xc) *(esi+0x10))
22396 $check-mu-length-stmt:check-no-inouts:
22397 3d/compare-eax-and 0/imm32
22398 0f 84/jump-if-= $check-mu-length-stmt:error-too-few-inouts/disp32
22399 (lookup *eax *(eax+4))
22400 89/<- %ecx 0/r32/eax
22401
22402
22403 (lookup *(ecx+8) *(ecx+0xc))
22404 89/<- %ebx 0/r32/eax
22405
22406 81 7/subop/compare *ebx 0/imm32/false
22407 {
22408 74/jump-if-= break/disp8
22409 (is-simple-mu-type? %ebx 3)
22410 3d/compare-eax-and 0/imm32/false
22411 0f 85/jump-if-!= $check-mu-length-stmt:error-base-array-atom-type/disp32
22412 0f 84/jump-if-= $check-mu-length-stmt:error-base-non-array-type/disp32
22413 }
22414 $check-mu-length-stmt:base-is-compound:
22415
22416 {
22417 (lookup *(ebx+4) *(ebx+8))
22418 (is-simple-mu-type? %eax 2)
22419 3d/compare-eax-and 0/imm32/false
22420 75/jump-if-!= break/disp8
22421 (lookup *(ebx+4) *(ebx+8))
22422 (is-simple-mu-type? %eax 3)
22423 3d/compare-eax-and 0/imm32/false
22424 75/jump-if-!= break/disp8
22425 e9/jump $check-mu-length-stmt:error-base-non-array-type/disp32
22426 }
22427
22428 {
22429 (lookup *(ebx+4) *(ebx+8))
22430 (is-simple-mu-type? %eax 2)
22431 3d/compare-eax-and 0/imm32/false
22432 74/jump-if-= break/disp8
22433 $check-mu-length-stmt:base-is-addr:
22434 (lookup *(ebx+0xc) *(ebx+0x10))
22435 (lookup *(eax+4) *(eax+8))
22436 (is-simple-mu-type? %eax 3)
22437 3d/compare-eax-and 0/imm32/false
22438 0f 84/jump-if-= $check-mu-length-stmt:error-base-non-array-type/disp32
22439 $check-mu-length-stmt:check-base-addr-is-register:
22440 81 7/subop/compare *(ecx+0x18) 0/imm32
22441 0f 84/jump-if-= $check-mu-length-stmt:error-base-address-array-type-on-stack/disp32
22442 }
22443
22444 {
22445 (lookup *(ebx+4) *(ebx+8))
22446 (is-simple-mu-type? %eax 3)
22447 3d/compare-eax-and 0/imm32/false
22448 74/jump-if-= break/disp8
22449 $check-mu-length-stmt:base-is-array:
22450 81 7/subop/compare *(ecx+0x18) 0/imm32
22451 0f 85/jump-if-!= $check-mu-length-stmt:error-base-array-type-in-register/disp32
22452 }
22453
22454 {
22455 (lookup *(ebx+4) *(ebx+8))
22456 (is-simple-mu-type? %eax 2)
22457 3d/compare-eax-and 0/imm32/false
22458 74/jump-if-= break/disp8
22459 (lookup *(ebx+0xc) *(ebx+0x10))
22460 89/<- %ebx 0/r32/eax
22461 }
22462
22463 (lookup *(esi+0xc) *(esi+0x10))
22464 (lookup *(eax+8) *(eax+0xc))
22465 3d/compare-eax-and 0/imm32/false
22466 0f 85/jump-if-!= $check-mu-length-stmt:error-too-many-inouts/disp32
22467
22468
22469 (lookup *(esi+0x14) *(esi+0x18))
22470 3d/compare-eax-and 0/imm32/false
22471 0f 84/jump-if-= $check-mu-length-stmt:error-too-few-outputs/disp32
22472 (lookup *eax *(eax+4))
22473 89/<- %edi 0/r32/eax
22474
22475
22476 (lookup *(edi+8) *(edi+0xc))
22477 (is-simple-mu-type? %eax 1)
22478 3d/compare-eax-and 0/imm32/false
22479 0f 84/jump-if-= $check-mu-length-stmt:error-invalid-output-type/disp32
22480
22481 (lookup *(esi+0x14) *(esi+0x18))
22482 (lookup *(eax+8) *(eax+0xc))
22483 3d/compare-eax-and 0/imm32/false
22484 0f 85/jump-if-!= $check-mu-length-stmt:error-too-many-outputs/disp32
22485 $check-mu-length-stmt:end:
22486
22487 5f/pop-to-edi
22488 5e/pop-to-esi
22489 5b/pop-to-ebx
22490 5a/pop-to-edx
22491 59/pop-to-ecx
22492 58/pop-to-eax
22493
22494 89/<- %esp 5/r32/ebp
22495 5d/pop-to-ebp
22496 c3/return
22497
22498 $check-mu-length-stmt:error-base-non-array-type:
22499 (write-buffered *(ebp+0x10) "fn ")
22500 8b/-> *(ebp+0xc) 0/r32/eax
22501 (lookup *eax *(eax+4))
22502 (write-buffered *(ebp+0x10) %eax)
22503 (write-buffered *(ebp+0x10) ": stmt length: var '")
22504 (lookup *ecx *(ecx+4))
22505 (write-buffered *(ebp+0x10) %eax)
22506 (write-buffered *(ebp+0x10) "' is not an array\n")
22507 (flush *(ebp+0x10))
22508 (stop *(ebp+0x14) 1)
22509
22510
22511 $check-mu-length-stmt:error-base-array-atom-type:
22512 (write-buffered *(ebp+0x10) "fn ")
22513 8b/-> *(ebp+0xc) 0/r32/eax
22514 (lookup *eax *(eax+4))
22515 (write-buffered *(ebp+0x10) %eax)
22516 (write-buffered *(ebp+0x10) ": stmt length: array '")
22517 (lookup *ecx *(ecx+4))
22518 (write-buffered *(ebp+0x10) %eax)
22519 (write-buffered *(ebp+0x10) "' must specify the type of its elements\n")
22520 (flush *(ebp+0x10))
22521 (stop *(ebp+0x14) 1)
22522
22523
22524 $check-mu-length-stmt:error-base-address-array-type-on-stack:
22525 (write-buffered *(ebp+0x10) "fn ")
22526 8b/-> *(ebp+0xc) 0/r32/eax
22527 (lookup *eax *(eax+4))
22528 (write-buffered *(ebp+0x10) %eax)
22529 (write-buffered *(ebp+0x10) ": stmt length: var '")
22530 (lookup *ecx *(ecx+4))
22531 (write-buffered *(ebp+0x10) %eax)
22532 (write-buffered *(ebp+0x10) "' is an addr to an array, and so must live in a register\n")
22533 (flush *(ebp+0x10))
22534 (stop *(ebp+0x14) 1)
22535
22536
22537 $check-mu-length-stmt:error-base-array-type-in-register:
22538 (write-buffered *(ebp+0x10) "fn ")
22539 8b/-> *(ebp+0xc) 0/r32/eax
22540 (lookup *eax *(eax+4))
22541 (write-buffered *(ebp+0x10) %eax)
22542 (write-buffered *(ebp+0x10) ": stmt length: var '")
22543 (lookup *ecx *(ecx+4))
22544 (write-buffered *(ebp+0x10) %eax)
22545 (write-buffered *(ebp+0x10) "' is an array, and so must live on the stack\n")
22546 (flush *(ebp+0x10))
22547 (stop *(ebp+0x14) 1)
22548
22549
22550 $check-mu-length-stmt:error-too-few-inouts:
22551 (write-buffered *(ebp+0x10) "fn ")
22552 8b/-> *(ebp+0xc) 0/r32/eax
22553 (lookup *eax *(eax+4))
22554 (write-buffered *(ebp+0x10) %eax)
22555 (write-buffered *(ebp+0x10) ": stmt length: too few inouts (1 required)\n")
22556 (flush *(ebp+0x10))
22557 (stop *(ebp+0x14) 1)
22558
22559
22560 $check-mu-length-stmt:error-invalid-index-type:
22561 (write-buffered *(ebp+0x10) "fn ")
22562 8b/-> *(ebp+0xc) 0/r32/eax
22563 (lookup *eax *(eax+4))
22564 (write-buffered *(ebp+0x10) %eax)
22565 (write-buffered *(ebp+0x10) ": stmt length: second argument '")
22566 (lookup *ecx *(ecx+4))
22567 (write-buffered *(ebp+0x10) %eax)
22568 (write-buffered *(ebp+0x10) "' must be an int or offset\n")
22569 (flush *(ebp+0x10))
22570 (stop *(ebp+0x14) 1)
22571
22572
22573 $check-mu-length-stmt:error-index-offset-atom-type:
22574 (write-buffered *(ebp+0x10) "fn ")
22575 8b/-> *(ebp+0xc) 0/r32/eax
22576 (lookup *eax *(eax+4))
22577 (write-buffered *(ebp+0x10) %eax)
22578 (write-buffered *(ebp+0x10) ": stmt length: offset '")
22579 (lookup *ecx *(ecx+4))
22580 (write-buffered *(ebp+0x10) %eax)
22581 (write-buffered *(ebp+0x10) "' must specify the type of array elements\n")
22582 (flush *(ebp+0x10))
22583 (stop *(ebp+0x14) 1)
22584
22585
22586 $check-mu-length-stmt:error-index-on-stack:
22587 (write-buffered *(ebp+0x10) "fn ")
22588 8b/-> *(ebp+0xc) 0/r32/eax
22589 (lookup *eax *(eax+4))
22590 (write-buffered *(ebp+0x10) %eax)
22591 (write-buffered *(ebp+0x10) ": stmt length: second argument '")
22592 (lookup *ecx *(ecx+4))
22593 (write-buffered *(ebp+0x10) %eax)
22594 (write-buffered *(ebp+0x10) "' must be in a register\n")
22595 (flush *(ebp+0x10))
22596 (stop *(ebp+0x14) 1)
22597
22598
22599 $check-mu-length-stmt:error-index-needs-offset:
22600 (write-buffered *(ebp+0x10) "fn ")
22601 8b/-> *(ebp+0xc) 0/r32/eax
22602 (lookup *eax *(eax+4))
22603 (write-buffered *(ebp+0x10) %eax)
22604 (write-buffered *(ebp+0x10) ": stmt length: cannot take an int for array '")
22605 (lookup *(esi+0xc) *(esi+0x10))
22606 (lookup *eax *(eax+4))
22607 (lookup *eax *(eax+4))
22608 (write-buffered *(ebp+0x10) %eax)
22609 (write-buffered *(ebp+0x10) "'; create an offset instead. See mu.md for details.\n")
22610 (flush *(ebp+0x10))
22611 (stop *(ebp+0x14) 1)
22612
22613
22614 $check-mu-length-stmt:error-too-many-inouts:
22615 (write-buffered *(ebp+0x10) "fn ")
22616 8b/-> *(ebp+0xc) 0/r32/eax
22617 (lookup *eax *(eax+4))
22618 (write-buffered *(ebp+0x10) %eax)
22619 (write-buffered *(ebp+0x10) ": stmt length: too many inouts (1 required)\n")
22620 (flush *(ebp+0x10))
22621 (stop *(ebp+0x14) 1)
22622
22623
22624 $check-mu-length-stmt:error-too-few-outputs:
22625 (write-buffered *(ebp+0x10) "fn ")
22626 8b/-> *(ebp+0xc) 0/r32/eax
22627 (lookup *eax *(eax+4))
22628 (write-buffered *(ebp+0x10) %eax)
22629 (write-buffered *(ebp+0x10) ": stmt length: must have an output\n")
22630 (flush *(ebp+0x10))
22631 (stop *(ebp+0x14) 1)
22632
22633
22634 $check-mu-length-stmt:error-too-many-outputs:
22635 (write-buffered *(ebp+0x10) "fn ")
22636 8b/-> *(ebp+0xc) 0/r32/eax
22637 (lookup *eax *(eax+4))
22638 (write-buffered *(ebp+0x10) %eax)
22639 (write-buffered *(ebp+0x10) ": stmt length: too many outputs (1 required)\n")
22640 (flush *(ebp+0x10))
22641 (stop *(ebp+0x14) 1)
22642
22643
22644 $check-mu-length-stmt:error-output-not-in-register:
22645 (write-buffered *(ebp+0x10) "fn ")
22646 8b/-> *(ebp+0xc) 0/r32/eax
22647 (lookup *eax *(eax+4))
22648 (write-buffered *(ebp+0x10) %eax)
22649 (write-buffered *(ebp+0x10) ": stmt length: output '")
22650 (lookup *edi *(edi+4))
22651 (write-buffered *(ebp+0x10) %eax)
22652 (write-buffered *(ebp+0x10) "' is not in a register\n")
22653 (flush *(ebp+0x10))
22654 (stop *(ebp+0x14) 1)
22655
22656
22657 $check-mu-length-stmt:error-invalid-output-type:
22658 (write-buffered *(ebp+0x10) "fn ")
22659 8b/-> *(ebp+0xc) 0/r32/eax
22660 (lookup *eax *(eax+4))
22661 (write-buffered *(ebp+0x10) %eax)
22662 (write-buffered *(ebp+0x10) ": stmt length: output '")
22663 (lookup *edi *(edi+4))
22664 (write-buffered *(ebp+0x10) %eax)
22665 (write-buffered *(ebp+0x10) "' does not have the right type\n")
22666 (flush *(ebp+0x10))
22667 (stop *(ebp+0x14) 1)
22668
22669
22670 check-mu-compute-offset-stmt:
22671
22672 55/push-ebp
22673 89/<- %ebp 4/r32/esp
22674
22675 50/push-eax
22676 51/push-ecx
22677 52/push-edx
22678 53/push-ebx
22679 56/push-esi
22680 57/push-edi
22681
22682 8b/-> *(ebp+8) 6/r32/esi
22683
22684
22685 (lookup *(esi+0xc) *(esi+0x10))
22686 $check-mu-compute-offset-stmt:check-no-inouts:
22687 3d/compare-eax-and 0/imm32
22688 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-too-few-inouts/disp32
22689 (lookup *eax *(eax+4))
22690 89/<- %ecx 0/r32/eax
22691
22692
22693 (lookup *(ecx+8) *(ecx+0xc))
22694 89/<- %ebx 0/r32/eax
22695
22696 81 7/subop/compare *ebx 0/imm32/false
22697 {
22698 74/jump-if-= break/disp8
22699 (is-simple-mu-type? %ebx 3)
22700 3d/compare-eax-and 0/imm32/false
22701 0f 85/jump-if-!= $check-mu-compute-offset-stmt:error-base-array-atom-type/disp32
22702 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-base-non-array-type/disp32
22703 }
22704 $check-mu-compute-offset-stmt:base-is-compound:
22705
22706 {
22707 (lookup *(ebx+4) *(ebx+8))
22708 (is-simple-mu-type? %eax 2)
22709 3d/compare-eax-and 0/imm32/false
22710 75/jump-if-!= break/disp8
22711 (lookup *(ebx+4) *(ebx+8))
22712 (is-simple-mu-type? %eax 3)
22713 3d/compare-eax-and 0/imm32/false
22714 75/jump-if-!= break/disp8
22715 e9/jump $check-mu-compute-offset-stmt:error-base-non-array-type/disp32
22716 }
22717
22718 {
22719 (lookup *(ebx+4) *(ebx+8))
22720 (is-simple-mu-type? %eax 2)
22721 3d/compare-eax-and 0/imm32/false
22722 74/jump-if-= break/disp8
22723 $check-mu-compute-offset-stmt:base-is-addr:
22724 (lookup *(ebx+0xc) *(ebx+0x10))
22725 (lookup *(eax+4) *(eax+8))
22726 (is-simple-mu-type? %eax 3)
22727 3d/compare-eax-and 0/imm32/false
22728 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-base-non-array-type/disp32
22729 }
22730
22731 {
22732 (lookup *(ebx+4) *(ebx+8))
22733 (is-simple-mu-type? %eax 2)
22734 3d/compare-eax-and 0/imm32/false
22735 74/jump-if-= break/disp8
22736 (lookup *(ebx+0xc) *(ebx+0x10))
22737 89/<- %ebx 0/r32/eax
22738 }
22739
22740
22741 (lookup *(esi+0xc) *(esi+0x10))
22742 (lookup *(eax+8) *(eax+0xc))
22743 $check-mu-compute-offset-stmt:check-single-inout:
22744 3d/compare-eax-and 0/imm32
22745 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-too-few-inouts/disp32
22746 (lookup *eax *(eax+4))
22747 89/<- %ecx 0/r32/eax
22748
22749
22750 (lookup *(ecx+8) *(ecx+0xc))
22751 89/<- %edx 0/r32/eax
22752
22753 81 7/subop/compare *edx 0/imm32/false
22754 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-invalid-index-type/disp32
22755 {
22756 $check-mu-compute-offset-stmt:index-type-is-atom:
22757 (is-simple-mu-type? %edx 0)
22758 3d/compare-eax-and 0/imm32/false
22759 75/jump-if-!= break/disp8
22760 (is-simple-mu-type? %edx 1)
22761 3d/compare-eax-and 0/imm32/false
22762 75/jump-if-!= break/disp8
22763 e9/jump $check-mu-compute-offset-stmt:error-invalid-index-type/disp32
22764 }
22765
22766 (lookup *(esi+0xc) *(esi+0x10))
22767 (lookup *(eax+8) *(eax+0xc))
22768 (lookup *(eax+8) *(eax+0xc))
22769 3d/compare-eax-and 0/imm32/false
22770 0f 85/jump-if-!= $check-mu-compute-offset-stmt:error-too-many-inouts/disp32
22771
22772
22773 (lookup *(esi+0x14) *(esi+0x18))
22774 3d/compare-eax-and 0/imm32/false
22775 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-too-few-outputs/disp32
22776 (lookup *eax *(eax+4))
22777 89/<- %edi 0/r32/eax
22778
22779
22780 (lookup *(edi+8) *(edi+0xc))
22781 89/<- %edx 0/r32/eax
22782 81 7/subop/compare *edx 0/imm32/false
22783 0f 85/jump-if-!= $check-mu-compute-offset-stmt:error-output-type-not-offset/disp32
22784
22785 (lookup *(edx+4) *(edx+8))
22786 (is-simple-mu-type? %eax 7)
22787 3d/compare-eax-and 0/imm32/false
22788 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-output-type-not-offset/disp32
22789
22790 (type-tail %ebx)
22791 89/<- %ebx 0/r32/eax
22792 (type-tail %edx)
22793 (type-equal? %ebx %eax)
22794 3d/compare-eax-and 0/imm32/false
22795 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-bad-output-type/disp32
22796
22797 (lookup *(esi+0x14) *(esi+0x18))
22798 (lookup *(eax+8) *(eax+0xc))
22799 3d/compare-eax-and 0/imm32/false
22800 0f 85/jump-if-!= $check-mu-compute-offset-stmt:error-too-many-outputs/disp32
22801 $check-mu-compute-offset-stmt:end:
22802
22803 5f/pop-to-edi
22804 5e/pop-to-esi
22805 5b/pop-to-ebx
22806 5a/pop-to-edx
22807 59/pop-to-ecx
22808 58/pop-to-eax
22809
22810 89/<- %esp 5/r32/ebp
22811 5d/pop-to-ebp
22812 c3/return
22813
22814 $check-mu-compute-offset-stmt:error-base-non-array-type:
22815 (write-buffered *(ebp+0x10) "fn ")
22816 8b/-> *(ebp+0xc) 0/r32/eax
22817 (lookup *eax *(eax+4))
22818 (write-buffered *(ebp+0x10) %eax)
22819 (write-buffered *(ebp+0x10) ": stmt compute-offset: var '")
22820 (lookup *ecx *(ecx+4))
22821 (write-buffered *(ebp+0x10) %eax)
22822 (write-buffered *(ebp+0x10) "' is not an array\n")
22823 (flush *(ebp+0x10))
22824 (stop *(ebp+0x14) 1)
22825
22826
22827 $check-mu-compute-offset-stmt:error-base-array-atom-type:
22828 (write-buffered *(ebp+0x10) "fn ")
22829 8b/-> *(ebp+0xc) 0/r32/eax
22830 (lookup *eax *(eax+4))
22831 (write-buffered *(ebp+0x10) %eax)
22832 (write-buffered *(ebp+0x10) ": stmt compute-offset: array '")
22833 (lookup *ecx *(ecx+4))
22834 (write-buffered *(ebp+0x10) %eax)
22835 (write-buffered *(ebp+0x10) "' must specify the type of its elements\n")
22836 (flush *(ebp+0x10))
22837 (stop *(ebp+0x14) 1)
22838
22839
22840 $check-mu-compute-offset-stmt:error-too-few-inouts:
22841 (write-buffered *(ebp+0x10) "fn ")
22842 8b/-> *(ebp+0xc) 0/r32/eax
22843 (lookup *eax *(eax+4))
22844 (write-buffered *(ebp+0x10) %eax)
22845 (write-buffered *(ebp+0x10) ": stmt compute-offset: too few inouts (2 required)\n")
22846 (flush *(ebp+0x10))
22847 (stop *(ebp+0x14) 1)
22848
22849
22850 $check-mu-compute-offset-stmt:error-invalid-index-type:
22851 (write-buffered *(ebp+0x10) "fn ")
22852 8b/-> *(ebp+0xc) 0/r32/eax
22853 (lookup *eax *(eax+4))
22854 (write-buffered *(ebp+0x10) %eax)
22855 (write-buffered *(ebp+0x10) ": stmt compute-offset: second argument '")
22856 (lookup *ecx *(ecx+4))
22857 (write-buffered *(ebp+0x10) %eax)
22858 (write-buffered *(ebp+0x10) "' must be an int\n")
22859 (flush *(ebp+0x10))
22860 (stop *(ebp+0x14) 1)
22861
22862
22863 $check-mu-compute-offset-stmt:error-index-offset-atom-type:
22864 (write-buffered *(ebp+0x10) "fn ")
22865 8b/-> *(ebp+0xc) 0/r32/eax
22866 (lookup *eax *(eax+4))
22867 (write-buffered *(ebp+0x10) %eax)
22868 (write-buffered *(ebp+0x10) ": stmt compute-offset: offset '")
22869 (lookup *ecx *(ecx+4))
22870 (write-buffered *(ebp+0x10) %eax)
22871 (write-buffered *(ebp+0x10) "' must specify the type of array elements\n")
22872 (flush *(ebp+0x10))
22873 (stop *(ebp+0x14) 1)
22874
22875
22876 $check-mu-compute-offset-stmt:error-index-on-stack:
22877 (write-buffered *(ebp+0x10) "fn ")
22878 8b/-> *(ebp+0xc) 0/r32/eax
22879 (lookup *eax *(eax+4))
22880 (write-buffered *(ebp+0x10) %eax)
22881 (write-buffered *(ebp+0x10) ": stmt compute-offset: second argument '")
22882 (lookup *ecx *(ecx+4))
22883 (write-buffered *(ebp+0x10) %eax)
22884 (write-buffered *(ebp+0x10) "' must be in a register\n")
22885 (flush *(ebp+0x10))
22886 (stop *(ebp+0x14) 1)
22887
22888
22889 $check-mu-compute-offset-stmt:error-too-many-inouts:
22890 (write-buffered *(ebp+0x10) "fn ")
22891 8b/-> *(ebp+0xc) 0/r32/eax
22892 (lookup *eax *(eax+4))
22893 (write-buffered *(ebp+0x10) %eax)
22894 (write-buffered *(ebp+0x10) ": stmt compute-offset: too many inouts (2 required)\n")
22895 (flush *(ebp+0x10))
22896 (stop *(ebp+0x14) 1)
22897
22898
22899 $check-mu-compute-offset-stmt:error-too-few-outputs:
22900 (write-buffered *(ebp+0x10) "fn ")
22901 8b/-> *(ebp+0xc) 0/r32/eax
22902 (lookup *eax *(eax+4))
22903 (write-buffered *(ebp+0x10) %eax)
22904 (write-buffered *(ebp+0x10) ": stmt compute-offset: must have an output\n")
22905 (flush *(ebp+0x10))
22906 (stop *(ebp+0x14) 1)
22907
22908
22909 $check-mu-compute-offset-stmt:error-too-many-outputs:
22910 (write-buffered *(ebp+0x10) "fn ")
22911 8b/-> *(ebp+0xc) 0/r32/eax
22912 (lookup *eax *(eax+4))
22913 (write-buffered *(ebp+0x10) %eax)
22914 (write-buffered *(ebp+0x10) ": stmt compute-offset: too many outputs (1 required)\n")
22915 (flush *(ebp+0x10))
22916 (stop *(ebp+0x14) 1)
22917
22918
22919 $check-mu-compute-offset-stmt:error-output-not-in-register:
22920 (write-buffered *(ebp+0x10) "fn ")
22921 8b/-> *(ebp+0xc) 0/r32/eax
22922 (lookup *eax *(eax+4))
22923 (write-buffered *(ebp+0x10) %eax)
22924 (write-buffered *(ebp+0x10) ": stmt compute-offset: output '")
22925 (lookup *edi *(edi+4))
22926 (write-buffered *(ebp+0x10) %eax)
22927 (write-buffered *(ebp+0x10) "' is not in a register\n")
22928 (flush *(ebp+0x10))
22929 (stop *(ebp+0x14) 1)
22930
22931
22932 $check-mu-compute-offset-stmt:error-output-type-not-offset:
22933 (write-buffered *(ebp+0x10) "fn ")
22934 8b/-> *(ebp+0xc) 0/r32/eax
22935 (lookup *eax *(eax+4))
22936 (write-buffered *(ebp+0x10) %eax)
22937 (write-buffered *(ebp+0x10) ": stmt compute-offset: output '")
22938 (lookup *edi *(edi+4))
22939 (write-buffered *(ebp+0x10) %eax)
22940 (write-buffered *(ebp+0x10) "' must be an offset\n")
22941 (flush *(ebp+0x10))
22942 (stop *(ebp+0x14) 1)
22943
22944
22945 $check-mu-compute-offset-stmt:error-bad-output-type:
22946 (write-buffered *(ebp+0x10) "fn ")
22947 8b/-> *(ebp+0xc) 0/r32/eax
22948 (lookup *eax *(eax+4))
22949 (write-buffered *(ebp+0x10) %eax)
22950 (write-buffered *(ebp+0x10) ": stmt compute-offset: output '")
22951 (lookup *edi *(edi+4))
22952 (write-buffered *(ebp+0x10) %eax)
22953 (write-buffered *(ebp+0x10) "' does not have the right type\n")
22954 (flush *(ebp+0x10))
22955 (stop *(ebp+0x14) 1)
22956
22957
22958 check-mu-copy-object-stmt:
22959
22960 55/push-ebp
22961 89/<- %ebp 4/r32/esp
22962
22963 50/push-eax
22964 51/push-ecx
22965 53/push-ebx
22966 56/push-esi
22967 57/push-edi
22968
22969 8b/-> *(ebp+8) 6/r32/esi
22970 $check-mu-copy-object-stmt:check-for-output:
22971
22972 (lookup *(esi+0x14) *(esi+0x18))
22973 3d/compare-eax-and 0/imm32
22974 0f 85/jump-if-!= $check-mu-copy-object-stmt:error-too-many-outputs/disp32
22975 $check-mu-copy-object-stmt:get-left:
22976
22977 (lookup *(esi+0xc) *(esi+0x10))
22978 89/<- %edi 0/r32/eax
22979
22980 3d/compare-eax-and 0/imm32
22981 0f 84/jump-if-= $check-mu-copy-object-stmt:error-incorrect-inouts/disp32
22982 $check-mu-copy-object-stmt:get-src:
22983
22984 (lookup *(edi+8) *(edi+0xc))
22985 89/<- %esi 0/r32/eax
22986
22987 3d/compare-eax-and 0/imm32
22988 0f 84/jump-if-= $check-mu-copy-object-stmt:error-incorrect-inouts/disp32
22989
22990 (lookup *(esi+8) *(esi+0xc))
22991 3d/compare-eax-and 0/imm32
22992 0f 85/jump-if-!= $check-mu-copy-object-stmt:error-incorrect-inouts/disp32
22993 $check-mu-copy-object-stmt:types:
22994
22995 (lookup *esi *(esi+4))
22996 (lookup *(eax+8) *(eax+0xc))
22997 89/<- %ecx 0/r32/eax
22998
22999 8b/-> *(esi+0x10) 0/r32/eax
23000 3d/compare-eax-and 0/imm32/false
23001 {
23002 74/jump-if-= break/disp8
23003 (lookup *(ecx+0xc) *(ecx+0x10))
23004
23005 81 7/subop/compare *(eax+0xc) 0/imm32
23006 {
23007 75/jump-if-!= break/disp8
23008 (lookup *(eax+4) *(eax+8))
23009 }
23010 89/<- %ecx 0/r32/eax
23011 }
23012
23013 (is-mu-addr-type? %ecx)
23014 3d/compare-eax-and 0/imm32/false
23015 0f 84/jump-if-= $check-mu-copy-object-stmt:error-invalid-types/disp32
23016
23017 (lookup *edi *(edi+4))
23018 (lookup *(eax+8) *(eax+0xc))
23019 89/<- %ebx 0/r32/eax
23020
23021 8b/-> *(edi+0x10) 0/r32/eax
23022 3d/compare-eax-and 0/imm32/false
23023 {
23024 74/jump-if-= break/disp8
23025 (lookup *(ebx+0xc) *(ebx+0x10))
23026
23027 81 7/subop/compare *(eax+0xc) 0/imm32
23028 {
23029 75/jump-if-!= break/disp8
23030 (lookup *(eax+4) *(eax+8))
23031 }
23032 89/<- %ebx 0/r32/eax
23033 }
23034
23035 (type-equal? %ecx %ebx)
23036 3d/compare-eax-and 0/imm32
23037 0f 84/jump-if-= $check-mu-copy-object-stmt:error-invalid-types/disp32
23038 $check-mu-copy-object-stmt:end:
23039
23040 5f/pop-to-edi
23041 5e/pop-to-esi
23042 5b/pop-to-ebx
23043 59/pop-to-ecx
23044 58/pop-to-eax
23045
23046 89/<- %esp 5/r32/ebp
23047 5d/pop-to-ebp
23048 c3/return
23049
23050 $check-mu-copy-object-stmt:error-incorrect-inouts:
23051 (write-buffered *(ebp+0x10) "fn ")
23052 8b/-> *(ebp+0xc) 0/r32/eax
23053 (lookup *eax *(eax+4))
23054 (write-buffered *(ebp+0x10) %eax)
23055 (write-buffered *(ebp+0x10) ": stmt 'copy-object' must have two inouts\n")
23056 (flush *(ebp+0x10))
23057 (stop *(ebp+0x14) 1)
23058
23059
23060 $check-mu-copy-object-stmt:error-too-many-outputs:
23061 (write-buffered *(ebp+0x10) "fn ")
23062 8b/-> *(ebp+0xc) 0/r32/eax
23063 (lookup *eax *(eax+4))
23064 (write-buffered *(ebp+0x10) %eax)
23065 (write-buffered *(ebp+0x10) ": stmt 'copy-object' must not have any outputs\n")
23066 (flush *(ebp+0x10))
23067 (stop *(ebp+0x14) 1)
23068
23069
23070 $check-mu-copy-object-stmt:error-invalid-types:
23071 (write-buffered *(ebp+0x10) "fn ")
23072 8b/-> *(ebp+0xc) 0/r32/eax
23073 (lookup *eax *(eax+4))
23074 (write-buffered *(ebp+0x10) %eax)
23075 (write-buffered *(ebp+0x10) ": stmt copy-object: two inouts with identical addr types expected\n")
23076 (flush *(ebp+0x10))
23077 (stop *(ebp+0x14) 1)
23078
23079
23080 check-mu-clear-object-stmt:
23081
23082 55/push-ebp
23083 89/<- %ebp 4/r32/esp
23084
23085 50/push-eax
23086 51/push-ecx
23087 53/push-ebx
23088 56/push-esi
23089 57/push-edi
23090
23091 8b/-> *(ebp+8) 6/r32/esi
23092 $check-mu-clear-object-stmt:check-for-output:
23093
23094 (lookup *(esi+0x14) *(esi+0x18))
23095 3d/compare-eax-and 0/imm32
23096 0f 85/jump-if-!= $check-mu-clear-object-stmt:error-too-many-outputs/disp32
23097 $check-mu-clear-object-stmt:get-left:
23098
23099 (lookup *(esi+0xc) *(esi+0x10))
23100 89/<- %edi 0/r32/eax
23101
23102 3d/compare-eax-and 0/imm32
23103 0f 84/jump-if-= $check-mu-clear-object-stmt:error-incorrect-inouts/disp32
23104 $check-mu-clear-object-stmt:get-src:
23105
23106 (lookup *(edi+8) *(edi+0xc))
23107 3d/compare-eax-and 0/imm32
23108 0f 85/jump-if-!= $check-mu-clear-object-stmt:error-incorrect-inouts/disp32
23109 $check-mu-clear-object-stmt:types:
23110
23111 (lookup *edi *(edi+4))
23112 (lookup *(eax+8) *(eax+0xc))
23113 89/<- %ecx 0/r32/eax
23114
23115 8b/-> *(edi+0x10) 0/r32/eax
23116 3d/compare-eax-and 0/imm32/false
23117 {
23118 74/jump-if-= break/disp8
23119 (lookup *(ecx+0xc) *(ecx+0x10))
23120
23121 81 7/subop/compare *(eax+0xc) 0/imm32
23122 {
23123 75/jump-if-!= break/disp8
23124 (lookup *(eax+4) *(eax+8))
23125 }
23126 89/<- %ecx 0/r32/eax
23127 }
23128
23129 (is-mu-addr-type? %ecx)
23130 3d/compare-eax-and 0/imm32/false
23131 0f 84/jump-if-= $check-mu-clear-object-stmt:error-invalid-type/disp32
23132 $check-mu-clear-object-stmt:end:
23133
23134 5f/pop-to-edi
23135 5e/pop-to-esi
23136 5b/pop-to-ebx
23137 59/pop-to-ecx
23138 58/pop-to-eax
23139
23140 89/<- %esp 5/r32/ebp
23141 5d/pop-to-ebp
23142 c3/return
23143
23144 $check-mu-clear-object-stmt:error-incorrect-inouts:
23145 (write-buffered *(ebp+0x10) "fn ")
23146 8b/-> *(ebp+0xc) 0/r32/eax
23147 (lookup *eax *(eax+4))
23148 (write-buffered *(ebp+0x10) %eax)
23149 (write-buffered *(ebp+0x10) ": stmt 'clear-object' must have a single inout\n")
23150 (flush *(ebp+0x10))
23151 (stop *(ebp+0x14) 1)
23152
23153
23154 $check-mu-clear-object-stmt:error-too-many-outputs:
23155 (write-buffered *(ebp+0x10) "fn ")
23156 8b/-> *(ebp+0xc) 0/r32/eax
23157 (lookup *eax *(eax+4))
23158 (write-buffered *(ebp+0x10) %eax)
23159 (write-buffered *(ebp+0x10) ": stmt 'clear-object' must not have any outputs\n")
23160 (flush *(ebp+0x10))
23161 (stop *(ebp+0x14) 1)
23162
23163
23164 $check-mu-clear-object-stmt:error-invalid-type:
23165 (write-buffered *(ebp+0x10) "fn ")
23166 8b/-> *(ebp+0xc) 0/r32/eax
23167 (lookup *eax *(eax+4))
23168 (write-buffered *(ebp+0x10) %eax)
23169 (write-buffered *(ebp+0x10) ": stmt clear-object: inout must have an addr type\n")
23170 (flush *(ebp+0x10))
23171 (stop *(ebp+0x14) 1)
23172
23173
23174 check-mu-allocate-stmt:
23175
23176 55/push-ebp
23177 89/<- %ebp 4/r32/esp
23178
23179 50/push-eax
23180 53/push-ebx
23181 56/push-esi
23182 57/push-edi
23183
23184 8b/-> *(ebp+8) 6/r32/esi
23185 $check-mu-allocate-stmt:check-for-output:
23186
23187 (lookup *(esi+0x14) *(esi+0x18))
23188 3d/compare-eax-and 0/imm32
23189 0f 85/jump-if-!= $check-mu-allocate-stmt:error-too-many-outputs/disp32
23190 $check-mu-allocate-stmt:get-target:
23191
23192 (lookup *(esi+0xc) *(esi+0x10))
23193 89/<- %edi 0/r32/eax
23194
23195 3d/compare-eax-and 0/imm32
23196 0f 84/jump-if-= $check-mu-allocate-stmt:error-incorrect-inouts/disp32
23197
23198 (lookup *(edi+8) *(edi+0xc))
23199 3d/compare-eax-and 0/imm32
23200 0f 85/jump-if-!= $check-mu-allocate-stmt:error-incorrect-inouts/disp32
23201 $check-mu-allocate-stmt:check-type:
23202
23203 (lookup *edi *(edi+4))
23204 (lookup *(eax+8) *(eax+0xc))
23205 89/<- %ebx 0/r32/eax
23206
23207 8b/-> *(edi+0x10) 0/r32/eax
23208 3d/compare-eax-and 0/imm32/false
23209 {
23210 74/jump-if-= break/disp8
23211 (lookup *(ebx+0xc) *(ebx+0x10))
23212
23213 81 7/subop/compare *(eax+0xc) 0/imm32
23214 {
23215 75/jump-if-!= break/disp8
23216 (lookup *(eax+4) *(eax+8))
23217 }
23218 89/<- %ebx 0/r32/eax
23219 }
23220
23221 (is-mu-addr-type? %ebx)
23222 3d/compare-eax-and 0/imm32/false
23223 0f 84/jump-if-= $check-mu-allocate-stmt:error-invalid-type/disp32
23224
23225 (lookup *(ebx+0xc) *(ebx+0x10))
23226 81 7/subop/compare *eax 0/imm32/false
23227 0f 85/jump-if-!= $check-mu-allocate-stmt:error-invalid-type/disp32
23228
23229 (lookup *(eax+4) *(eax+8))
23230 (is-simple-mu-type? %eax 4)
23231 3d/compare-eax-and 0/imm32/false
23232 0f 84/jump-if-= $check-mu-allocate-stmt:error-invalid-type/disp32
23233 $check-mu-allocate-stmt:end:
23234
23235 5f/pop-to-edi
23236 5e/pop-to-esi
23237 5b/pop-to-ebx
23238 58/pop-to-eax
23239
23240 89/<- %esp 5/r32/ebp
23241 5d/pop-to-ebp
23242 c3/return
23243
23244 $check-mu-allocate-stmt:error-incorrect-inouts:
23245 (write-buffered *(ebp+0x10) "fn ")
23246 8b/-> *(ebp+0xc) 0/r32/eax
23247 (lookup *eax *(eax+4))
23248 (write-buffered *(ebp+0x10) %eax)
23249 (write-buffered *(ebp+0x10) ": stmt 'allocate' must have a single inout\n")
23250 (flush *(ebp+0x10))
23251 (stop *(ebp+0x14) 1)
23252
23253
23254 $check-mu-allocate-stmt:error-too-many-outputs:
23255 (write-buffered *(ebp+0x10) "fn ")
23256 8b/-> *(ebp+0xc) 0/r32/eax
23257 (lookup *eax *(eax+4))
23258 (write-buffered *(ebp+0x10) %eax)
23259 (write-buffered *(ebp+0x10) ": stmt 'allocate' must not have any outputs\n")
23260 (flush *(ebp+0x10))
23261 (stop *(ebp+0x14) 1)
23262
23263
23264 $check-mu-allocate-stmt:error-invalid-type:
23265 (write-buffered *(ebp+0x10) "fn ")
23266 8b/-> *(ebp+0xc) 0/r32/eax
23267 (lookup *eax *(eax+4))
23268 (write-buffered *(ebp+0x10) %eax)
23269 (write-buffered *(ebp+0x10) ": stmt allocate: inout '")
23270 (lookup *edi *(edi+4))
23271 (lookup *eax *(eax+4))
23272 (write-buffered *(ebp+0x10) %eax)
23273 (write-buffered *(ebp+0x10) "' must have type (addr handle ...)\n")
23274 (flush *(ebp+0x10))
23275 (stop *(ebp+0x14) 1)
23276
23277
23278 check-mu-populate-stmt:
23279
23280 55/push-ebp
23281 89/<- %ebp 4/r32/esp
23282
23283 50/push-eax
23284 53/push-ebx
23285 56/push-esi
23286 57/push-edi
23287
23288 8b/-> *(ebp+8) 6/r32/esi
23289 $check-mu-populate-stmt:check-for-output:
23290
23291 (lookup *(esi+0x14) *(esi+0x18))
23292 3d/compare-eax-and 0/imm32
23293 0f 85/jump-if-!= $check-mu-populate-stmt:error-too-many-outputs/disp32
23294 $check-mu-populate-stmt:get-target:
23295
23296 (lookup *(esi+0xc) *(esi+0x10))
23297 89/<- %edi 0/r32/eax
23298
23299 3d/compare-eax-and 0/imm32
23300 0f 84/jump-if-= $check-mu-populate-stmt:error-incorrect-inouts/disp32
23301 $check-mu-populate-stmt:get-length:
23302
23303 (lookup *(edi+8) *(edi+0xc))
23304 89/<- %esi 0/r32/eax
23305
23306 3d/compare-eax-and 0/imm32
23307 0f 84/jump-if-= $check-mu-populate-stmt:error-incorrect-inouts/disp32
23308
23309 (lookup *(esi+8) *(esi+0xc))
23310 3d/compare-eax-and 0/imm32
23311 0f 85/jump-if-!= $check-mu-populate-stmt:error-incorrect-inouts/disp32
23312 $check-mu-populate-stmt:check-target-type:
23313
23314 (lookup *edi *(edi+4))
23315 (lookup *(eax+8) *(eax+0xc))
23316 89/<- %ebx 0/r32/eax
23317 $check-mu-populate-stmt:check-target-type-deref:
23318
23319 8b/-> *(edi+0x10) 0/r32/eax
23320 3d/compare-eax-and 0/imm32/false
23321 {
23322 74/jump-if-= break/disp8
23323 (lookup *(ebx+0xc) *(ebx+0x10))
23324
23325 81 7/subop/compare *(eax+0xc) 0/imm32
23326 {
23327 75/jump-if-!= break/disp8
23328 (lookup *(eax+4) *(eax+8))
23329 }
23330 89/<- %ebx 0/r32/eax
23331 }
23332 $check-mu-populate-stmt:check-target-type-addr:
23333
23334 (is-mu-addr-type? %ebx)
23335 3d/compare-eax-and 0/imm32/false
23336 0f 84/jump-if-= $check-mu-populate-stmt:error-invalid-target-type/disp32
23337
23338 (lookup *(ebx+0xc) *(ebx+0x10))
23339 89/<- %ebx 0/r32/eax
23340 81 7/subop/compare *ebx 0/imm32/false
23341 0f 85/jump-if-!= $check-mu-populate-stmt:error-invalid-target-type/disp32
23342 $check-mu-populate-stmt:check-target-type-handle:
23343
23344 (lookup *(ebx+4) *(ebx+8))
23345 (is-simple-mu-type? %eax 4)
23346 3d/compare-eax-and 0/imm32/false
23347 0f 84/jump-if-= $check-mu-populate-stmt:error-invalid-target-type/disp32
23348
23349 (lookup *(ebx+0xc) *(ebx+0x10))
23350 89/<- %ebx 0/r32/eax
23351 81 7/subop/compare *ebx 0/imm32/false
23352 0f 85/jump-if-!= $check-mu-populate-stmt:error-invalid-target-type/disp32
23353 $check-mu-populate-stmt:check-target-type-array:
23354
23355 (lookup *(ebx+4) *(ebx+8))
23356 (is-simple-mu-type? %eax 3)
23357 3d/compare-eax-and 0/imm32/false
23358 0f 84/jump-if-= $check-mu-populate-stmt:error-invalid-target-type/disp32
23359 $check-mu-populate-stmt:check-length-type:
23360 (lookup *esi *(esi+4))
23361 (lookup *(eax+8) *(eax+0xc))
23362 89/<- %ebx 0/r32/eax
23363 (is-simple-mu-type? %ebx 0)
23364 3d/compare-eax-and 0/imm32/false
23365 75/jump-if-!= $check-mu-populate-stmt:end/disp8
23366 (is-simple-mu-type? %ebx 1)
23367 3d/compare-eax-and 0/imm32/false
23368 0f 84/jump-if-= $check-mu-populate-stmt:error-invalid-length-type/disp32
23369 $check-mu-populate-stmt:end:
23370
23371 5f/pop-to-edi
23372 5e/pop-to-esi
23373 5b/pop-to-ebx
23374 58/pop-to-eax
23375
23376 89/<- %esp 5/r32/ebp
23377 5d/pop-to-ebp
23378 c3/return
23379
23380 $check-mu-populate-stmt:error-incorrect-inouts:
23381 (write-buffered *(ebp+0x10) "fn ")
23382 8b/-> *(ebp+0xc) 0/r32/eax
23383 (lookup *eax *(eax+4))
23384 (write-buffered *(ebp+0x10) %eax)
23385 (write-buffered *(ebp+0x10) ": stmt 'populate' must have two inouts\n")
23386 (flush *(ebp+0x10))
23387 (stop *(ebp+0x14) 1)
23388
23389
23390 $check-mu-populate-stmt:error-too-many-outputs:
23391 (write-buffered *(ebp+0x10) "fn ")
23392 8b/-> *(ebp+0xc) 0/r32/eax
23393 (lookup *eax *(eax+4))
23394 (write-buffered *(ebp+0x10) %eax)
23395 (write-buffered *(ebp+0x10) ": stmt 'populate' must not have any outputs\n")
23396 (flush *(ebp+0x10))
23397 (stop *(ebp+0x14) 1)
23398
23399
23400 $check-mu-populate-stmt:error-invalid-target-type:
23401 (write-buffered *(ebp+0x10) "fn ")
23402 8b/-> *(ebp+0xc) 0/r32/eax
23403 (lookup *eax *(eax+4))
23404 (write-buffered *(ebp+0x10) %eax)
23405 (write-buffered *(ebp+0x10) ": stmt populate: first inout '")
23406 (lookup *edi *(edi+4))
23407 (lookup *eax *(eax+4))
23408 (write-buffered *(ebp+0x10) %eax)
23409 (write-buffered *(ebp+0x10) "' must have type (addr handle array ...)\n")
23410 (flush *(ebp+0x10))
23411 (stop *(ebp+0x14) 1)
23412
23413
23414 $check-mu-populate-stmt:error-invalid-length-type:
23415 (write-buffered *(ebp+0x10) "fn ")
23416 8b/-> *(ebp+0xc) 0/r32/eax
23417 (lookup *eax *(eax+4))
23418 (write-buffered *(ebp+0x10) %eax)
23419 (write-buffered *(ebp+0x10) ": stmt populate: second inout '")
23420 (lookup *esi *(esi+4))
23421 (lookup *eax *(eax+4))
23422 (write-buffered *(ebp+0x10) %eax)
23423 (write-buffered *(ebp+0x10) "' must be an int\n")
23424 (flush *(ebp+0x10))
23425 (stop *(ebp+0x14) 1)
23426
23427
23428 check-mu-populate-stream-stmt:
23429
23430 55/push-ebp
23431 89/<- %ebp 4/r32/esp
23432
23433 50/push-eax
23434 53/push-ebx
23435 56/push-esi
23436 57/push-edi
23437
23438 8b/-> *(ebp+8) 6/r32/esi
23439 $check-mu-populate-stream-stmt:check-for-output:
23440
23441 (lookup *(esi+0x14) *(esi+0x18))
23442 3d/compare-eax-and 0/imm32
23443 0f 85/jump-if-!= $check-mu-populate-stream-stmt:error-too-many-outputs/disp32
23444 $check-mu-populate-stream-stmt:get-target:
23445
23446 (lookup *(esi+0xc) *(esi+0x10))
23447 89/<- %edi 0/r32/eax
23448
23449 3d/compare-eax-and 0/imm32
23450 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-incorrect-inouts/disp32
23451 $check-mu-populate-stream-stmt:get-length:
23452
23453 (lookup *(edi+8) *(edi+0xc))
23454 89/<- %esi 0/r32/eax
23455
23456 3d/compare-eax-and 0/imm32
23457 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-incorrect-inouts/disp32
23458
23459 (lookup *(esi+8) *(esi+0xc))
23460 3d/compare-eax-and 0/imm32
23461 0f 85/jump-if-!= $check-mu-populate-stream-stmt:error-incorrect-inouts/disp32
23462 $check-mu-populate-stream-stmt:check-target-type:
23463
23464 (lookup *edi *(edi+4))
23465 (lookup *(eax+8) *(eax+0xc))
23466 89/<- %ebx 0/r32/eax
23467 $check-mu-populate-stream-stmt:check-target-type-deref:
23468
23469 8b/-> *(edi+0x10) 0/r32/eax
23470 3d/compare-eax-and 0/imm32/false
23471 {
23472 74/jump-if-= break/disp8
23473 (lookup *(ebx+0xc) *(ebx+0x10))
23474
23475 81 7/subop/compare *(eax+0xc) 0/imm32
23476 {
23477 75/jump-if-!= break/disp8
23478 (lookup *(eax+4) *(eax+8))
23479 }
23480 89/<- %ebx 0/r32/eax
23481 }
23482 $check-mu-populate-stream-stmt:check-target-type-addr:
23483
23484 (is-mu-addr-type? %ebx)
23485 3d/compare-eax-and 0/imm32/false
23486 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32
23487
23488 (lookup *(ebx+0xc) *(ebx+0x10))
23489 89/<- %ebx 0/r32/eax
23490 81 7/subop/compare *ebx 0/imm32/false
23491 0f 85/jump-if-!= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32
23492 $check-mu-populate-stream-stmt:check-target-type-handle:
23493
23494 (lookup *(ebx+4) *(ebx+8))
23495 (is-simple-mu-type? %eax 4)
23496 3d/compare-eax-and 0/imm32/false
23497 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32
23498
23499 (lookup *(ebx+0xc) *(ebx+0x10))
23500 89/<- %ebx 0/r32/eax
23501 81 7/subop/compare *ebx 0/imm32/false
23502 0f 85/jump-if-!= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32
23503 $check-mu-populate-stream-stmt:check-target-type-stream:
23504
23505 (lookup *(ebx+4) *(ebx+8))
23506 (is-simple-mu-type? %eax 0xb)
23507 3d/compare-eax-and 0/imm32/false
23508 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32
23509 $check-mu-populate-stream-stmt:check-length-type:
23510 (lookup *esi *(esi+4))
23511 (lookup *(eax+8) *(eax+0xc))
23512 89/<- %ebx 0/r32/eax
23513 (is-simple-mu-type? %ebx 0)
23514 3d/compare-eax-and 0/imm32/false
23515 75/jump-if-!= $check-mu-populate-stream-stmt:end/disp8
23516 (is-simple-mu-type? %ebx 1)
23517 3d/compare-eax-and 0/imm32/false
23518 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-invalid-length-type/disp32
23519 $check-mu-populate-stream-stmt:end:
23520
23521 5f/pop-to-edi
23522 5e/pop-to-esi
23523 5b/pop-to-ebx
23524 58/pop-to-eax
23525
23526 89/<- %esp 5/r32/ebp
23527 5d/pop-to-ebp
23528 c3/return
23529
23530 $check-mu-populate-stream-stmt:error-incorrect-inouts:
23531 (write-buffered *(ebp+0x10) "fn ")
23532 8b/-> *(ebp+0xc) 0/r32/eax
23533 (lookup *eax *(eax+4))
23534 (write-buffered *(ebp+0x10) %eax)
23535 (write-buffered *(ebp+0x10) ": stmt 'populate-stream' must have two inouts\n")
23536 (flush *(ebp+0x10))
23537 (stop *(ebp+0x14) 1)
23538
23539
23540 $check-mu-populate-stream-stmt:error-too-many-outputs:
23541 (write-buffered *(ebp+0x10) "fn ")
23542 8b/-> *(ebp+0xc) 0/r32/eax
23543 (lookup *eax *(eax+4))
23544 (write-buffered *(ebp+0x10) %eax)
23545 (write-buffered *(ebp+0x10) ": stmt 'populate-stream' must not have any outputs\n")
23546 (flush *(ebp+0x10))
23547 (stop *(ebp+0x14) 1)
23548
23549
23550 $check-mu-populate-stream-stmt:error-invalid-target-type:
23551 (write-buffered *(ebp+0x10) "fn ")
23552 8b/-> *(ebp+0xc) 0/r32/eax
23553 (lookup *eax *(eax+4))
23554 (write-buffered *(ebp+0x10) %eax)
23555 (write-buffered *(ebp+0x10) ": stmt populate-stream: first inout '")
23556 (lookup *edi *(edi+4))
23557 (lookup *eax *(eax+4))
23558 (write-buffered *(ebp+0x10) %eax)
23559 (write-buffered *(ebp+0x10) "' must have type (addr handle stream ...)\n")
23560 (flush *(ebp+0x10))
23561 (stop *(ebp+0x14) 1)
23562
23563
23564 $check-mu-populate-stream-stmt:error-invalid-length-type:
23565 (write-buffered *(ebp+0x10) "fn ")
23566 8b/-> *(ebp+0xc) 0/r32/eax
23567 (lookup *eax *(eax+4))
23568 (write-buffered *(ebp+0x10) %eax)
23569 (write-buffered *(ebp+0x10) ": stmt populate-stream: second inout '")
23570 (lookup *esi *(esi+4))
23571 (lookup *eax *(eax+4))
23572 (write-buffered *(ebp+0x10) %eax)
23573 (write-buffered *(ebp+0x10) "' must be an int\n")
23574 (flush *(ebp+0x10))
23575 (stop *(ebp+0x14) 1)
23576
23577
23578 check-mu-read-from-stream-stmt:
23579
23580 55/push-ebp
23581 89/<- %ebp 4/r32/esp
23582
23583 50/push-eax
23584 51/push-ecx
23585 52/push-edx
23586 53/push-ebx
23587 56/push-esi
23588 57/push-edi
23589
23590 8b/-> *(ebp+8) 6/r32/esi
23591
23592
23593 (lookup *(esi+0xc) *(esi+0x10))
23594 $check-mu-read-from-stream-stmt:check-no-inouts:
23595 3d/compare-eax-and 0/imm32
23596 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-too-few-inouts/disp32
23597 (lookup *eax *(eax+4))
23598 89/<- %ecx 0/r32/eax
23599
23600
23601 (lookup *(ecx+8) *(ecx+0xc))
23602 89/<- %ebx 0/r32/eax
23603 $check-mu-read-from-stream-stmt:check-base-is-compound:
23604
23605 81 7/subop/compare *ebx 0/imm32/false
23606 0f 85/jump-if-!= $check-mu-read-from-stream-stmt:error-invalid-base-type/disp32
23607 $check-mu-read-from-stream-stmt:check-base-is-addr:
23608
23609 (lookup *(ebx+4) *(ebx+8))
23610 (is-simple-mu-type? %eax 2)
23611 3d/compare-eax-and 0/imm32/false
23612 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-invalid-base-type/disp32
23613 $check-mu-read-from-stream-stmt:check-base-is-addr-to-stream:
23614
23615 (lookup *(ebx+0xc) *(ebx+0x10))
23616 89/<- %ebx 0/r32/eax
23617
23618 (lookup *(eax+4) *(eax+8))
23619 (is-simple-mu-type? %eax 0xb)
23620 3d/compare-eax-and 0/imm32/false
23621 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-invalid-base-type/disp32
23622
23623
23624 (lookup *(esi+0xc) *(esi+0x10))
23625 (lookup *(eax+8) *(eax+0xc))
23626 $check-mu-read-from-stream-stmt:check-single-inout:
23627 3d/compare-eax-and 0/imm32
23628 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-too-few-inouts/disp32
23629 (lookup *eax *(eax+4))
23630 89/<- %ecx 0/r32/eax
23631
23632 (lookup *(ecx+8) *(ecx+0xc))
23633 89/<- %edx 0/r32/eax
23634
23635 $check-mu-read-from-stream-stmt:check-target-is-compound:
23636 81 7/subop/compare *edx 0/imm32/false
23637 0f 85/jump-if-!= $check-mu-read-from-stream-stmt:error-target-type-not-address/disp32
23638 $check-mu-read-from-stream-stmt:check-target-type:
23639
23640 (lookup *(edx+4) *(edx+8))
23641 (is-simple-mu-type? %eax 2)
23642 3d/compare-eax-and 0/imm32/false
23643 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-target-type-not-address/disp32
23644
23645 (type-tail %ebx)
23646 89/<- %ebx 0/r32/eax
23647 (type-tail %edx)
23648 (type-equal? %ebx %eax)
23649 3d/compare-eax-and 0/imm32/false
23650 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-invalid-target-type/disp32
23651 $check-mu-read-from-stream-stmt:check-too-many-inouts:
23652
23653 (lookup *(esi+0xc) *(esi+0x10))
23654 (lookup *(eax+8) *(eax+0xc))
23655 (lookup *(eax+8) *(eax+0xc))
23656 3d/compare-eax-and 0/imm32/false
23657 0f 85/jump-if-!= $check-mu-read-from-stream-stmt:error-too-many-inouts/disp32
23658 $check-mu-read-from-stream-stmt:check-unexpected-output:
23659
23660 (lookup *(esi+0x14) *(esi+0x18))
23661 3d/compare-eax-and 0/imm32/false
23662 0f 85/jump-if-!= $check-mu-read-from-stream-stmt:error-unexpected-output/disp32
23663 $check-mu-read-from-stream-stmt:end:
23664
23665 5f/pop-to-edi
23666 5e/pop-to-esi
23667 5b/pop-to-ebx
23668 5a/pop-to-edx
23669 59/pop-to-ecx
23670 58/pop-to-eax
23671
23672 89/<- %esp 5/r32/ebp
23673 5d/pop-to-ebp
23674 c3/return
23675
23676 $check-mu-read-from-stream-stmt:error-invalid-base-type:
23677 (write-buffered *(ebp+0x10) "fn ")
23678 8b/-> *(ebp+0xc) 0/r32/eax
23679 (lookup *eax *(eax+4))
23680 (write-buffered *(ebp+0x10) %eax)
23681 (write-buffered *(ebp+0x10) ": stmt read-from-stream: var '")
23682 (lookup *ecx *(ecx+4))
23683 (write-buffered *(ebp+0x10) %eax)
23684 (write-buffered *(ebp+0x10) "' must be an addr to a stream\n")
23685 (flush *(ebp+0x10))
23686 (stop *(ebp+0x14) 1)
23687
23688
23689 $check-mu-read-from-stream-stmt:error-too-few-inouts:
23690 (write-buffered *(ebp+0x10) "fn ")
23691 8b/-> *(ebp+0xc) 0/r32/eax
23692 (lookup *eax *(eax+4))
23693 (write-buffered *(ebp+0x10) %eax)
23694 (write-buffered *(ebp+0x10) ": stmt read-from-stream: too few inouts (2 required)\n")
23695 (flush *(ebp+0x10))
23696 (stop *(ebp+0x14) 1)
23697
23698
23699 $check-mu-read-from-stream-stmt:error-target-type-not-address:
23700 (write-buffered *(ebp+0x10) "fn ")
23701 8b/-> *(ebp+0xc) 0/r32/eax
23702 (lookup *eax *(eax+4))
23703 (write-buffered *(ebp+0x10) %eax)
23704 (write-buffered *(ebp+0x10) ": stmt read-from-stream: target '")
23705 (lookup *ecx *(ecx+4))
23706 (write-buffered *(ebp+0x10) %eax)
23707 (write-buffered *(ebp+0x10) "' must be an addr\n")
23708 (flush *(ebp+0x10))
23709 (stop *(ebp+0x14) 1)
23710
23711
23712 $check-mu-read-from-stream-stmt:error-invalid-target-type:
23713 (write-buffered *(ebp+0x10) "fn ")
23714 8b/-> *(ebp+0xc) 0/r32/eax
23715 (lookup *eax *(eax+4))
23716 (write-buffered *(ebp+0x10) %eax)
23717 (write-buffered *(ebp+0x10) ": stmt read-from-stream: second inout '")
23718 (lookup *ecx *(ecx+4))
23719 (write-buffered *(ebp+0x10) %eax)
23720 (write-buffered *(ebp+0x10) "' does not have the right type\n")
23721 (flush *(ebp+0x10))
23722 (stop *(ebp+0x14) 1)
23723
23724
23725 $check-mu-read-from-stream-stmt:error-too-many-inouts:
23726 (write-buffered *(ebp+0x10) "fn ")
23727 8b/-> *(ebp+0xc) 0/r32/eax
23728 (lookup *eax *(eax+4))
23729 (write-buffered *(ebp+0x10) %eax)
23730 (write-buffered *(ebp+0x10) ": stmt read-from-stream: too many inouts (2 required)\n")
23731 (flush *(ebp+0x10))
23732 (stop *(ebp+0x14) 1)
23733
23734
23735 $check-mu-read-from-stream-stmt:error-unexpected-output:
23736 (write-buffered *(ebp+0x10) "fn ")
23737 8b/-> *(ebp+0xc) 0/r32/eax
23738 (lookup *eax *(eax+4))
23739 (write-buffered *(ebp+0x10) %eax)
23740 (write-buffered *(ebp+0x10) ": stmt read-from-stream: unexpected output\n")
23741 (flush *(ebp+0x10))
23742 (stop *(ebp+0x14) 1)
23743
23744
23745 check-mu-write-to-stream-stmt:
23746
23747 55/push-ebp
23748 89/<- %ebp 4/r32/esp
23749
23750 50/push-eax
23751 51/push-ecx
23752 52/push-edx
23753 53/push-ebx
23754 56/push-esi
23755 57/push-edi
23756
23757 8b/-> *(ebp+8) 6/r32/esi
23758
23759
23760 (lookup *(esi+0xc) *(esi+0x10))
23761 $check-mu-write-to-stream-stmt:check-no-inouts:
23762 3d/compare-eax-and 0/imm32
23763 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-too-few-inouts/disp32
23764 (lookup *eax *(eax+4))
23765 89/<- %ecx 0/r32/eax
23766
23767
23768 (lookup *(ecx+8) *(ecx+0xc))
23769 89/<- %ebx 0/r32/eax
23770 $check-mu-write-to-stream-stmt:check-base-is-compound:
23771
23772 81 7/subop/compare *ebx 0/imm32/false
23773 0f 85/jump-if-!= $check-mu-write-to-stream-stmt:error-invalid-base-type/disp32
23774 $check-mu-write-to-stream-stmt:check-base-is-addr:
23775
23776 (lookup *(ebx+4) *(ebx+8))
23777 (is-simple-mu-type? %eax 2)
23778 3d/compare-eax-and 0/imm32/false
23779 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-invalid-base-type/disp32
23780 $check-mu-write-to-stream-stmt:check-base-is-addr-to-stream:
23781
23782 (lookup *(ebx+0xc) *(ebx+0x10))
23783 89/<- %ebx 0/r32/eax
23784
23785 (lookup *(eax+4) *(eax+8))
23786 (is-simple-mu-type? %eax 0xb)
23787 3d/compare-eax-and 0/imm32/false
23788 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-invalid-base-type/disp32
23789
23790
23791 (lookup *(esi+0xc) *(esi+0x10))
23792 (lookup *(eax+8) *(eax+0xc))
23793 $check-mu-write-to-stream-stmt:check-single-inout:
23794 3d/compare-eax-and 0/imm32
23795 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-too-few-inouts/disp32
23796 (lookup *eax *(eax+4))
23797 89/<- %ecx 0/r32/eax
23798
23799 (lookup *(ecx+8) *(ecx+0xc))
23800 89/<- %edx 0/r32/eax
23801
23802 $check-mu-write-to-stream-stmt:check-target-is-compound:
23803 81 7/subop/compare *edx 0/imm32/false
23804 0f 85/jump-if-!= $check-mu-write-to-stream-stmt:error-target-type-not-address/disp32
23805 $check-mu-write-to-stream-stmt:check-target-type:
23806
23807 (lookup *(edx+4) *(edx+8))
23808 (is-simple-mu-type? %eax 2)
23809 3d/compare-eax-and 0/imm32/false
23810 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-target-type-not-address/disp32
23811
23812 (type-tail %ebx)
23813 89/<- %ebx 0/r32/eax
23814 (type-tail %edx)
23815 (type-equal? %ebx %eax)
23816 3d/compare-eax-and 0/imm32/false
23817 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-invalid-target-type/disp32
23818 $check-mu-write-to-stream-stmt:check-too-many-inouts:
23819
23820 (lookup *(esi+0xc) *(esi+0x10))
23821 (lookup *(eax+8) *(eax+0xc))
23822 (lookup *(eax+8) *(eax+0xc))
23823 3d/compare-eax-and 0/imm32/false
23824 0f 85/jump-if-!= $check-mu-write-to-stream-stmt:error-too-many-inouts/disp32
23825 $check-mu-write-to-stream-stmt:check-unexpected-output:
23826
23827 (lookup *(esi+0x14) *(esi+0x18))
23828 3d/compare-eax-and 0/imm32/false
23829 0f 85/jump-if-!= $check-mu-write-to-stream-stmt:error-unexpected-output/disp32
23830 $check-mu-write-to-stream-stmt:end:
23831
23832 5f/pop-to-edi
23833 5e/pop-to-esi
23834 5b/pop-to-ebx
23835 5a/pop-to-edx
23836 59/pop-to-ecx
23837 58/pop-to-eax
23838
23839 89/<- %esp 5/r32/ebp
23840 5d/pop-to-ebp
23841 c3/return
23842
23843 $check-mu-write-to-stream-stmt:error-invalid-base-type:
23844 (write-buffered *(ebp+0x10) "fn ")
23845 8b/-> *(ebp+0xc) 0/r32/eax
23846 (lookup *eax *(eax+4))
23847 (write-buffered *(ebp+0x10) %eax)
23848 (write-buffered *(ebp+0x10) ": stmt write-to-stream: var '")
23849 (lookup *ecx *(ecx+4))
23850 (write-buffered *(ebp+0x10) %eax)
23851 (write-buffered *(ebp+0x10) "' must be an addr to a stream\n")
23852 (flush *(ebp+0x10))
23853 (stop *(ebp+0x14) 1)
23854
23855
23856 $check-mu-write-to-stream-stmt:error-too-few-inouts:
23857 (write-buffered *(ebp+0x10) "fn ")
23858 8b/-> *(ebp+0xc) 0/r32/eax
23859 (lookup *eax *(eax+4))
23860 (write-buffered *(ebp+0x10) %eax)
23861 (write-buffered *(ebp+0x10) ": stmt write-to-stream: too few inouts (2 required)\n")
23862 (flush *(ebp+0x10))
23863 (stop *(ebp+0x14) 1)
23864
23865
23866 $check-mu-write-to-stream-stmt:error-target-type-not-address:
23867 (write-buffered *(ebp+0x10) "fn ")
23868 8b/-> *(ebp+0xc) 0/r32/eax
23869 (lookup *eax *(eax+4))
23870 (write-buffered *(ebp+0x10) %eax)
23871 (write-buffered *(ebp+0x10) ": stmt write-to-stream: target '")
23872 (lookup *ecx *(ecx+4))
23873 (write-buffered *(ebp+0x10) %eax)
23874 (write-buffered *(ebp+0x10) "' must be an addr\n")
23875 (flush *(ebp+0x10))
23876 (stop *(ebp+0x14) 1)
23877
23878
23879 $check-mu-write-to-stream-stmt:error-invalid-target-type:
23880 (write-buffered *(ebp+0x10) "fn ")
23881 8b/-> *(ebp+0xc) 0/r32/eax
23882 (lookup *eax *(eax+4))
23883 (write-buffered *(ebp+0x10) %eax)
23884 (write-buffered *(ebp+0x10) ": stmt write-to-stream: second inout '")
23885 (lookup *ecx *(ecx+4))
23886 (write-buffered *(ebp+0x10) %eax)
23887 (write-buffered *(ebp+0x10) "' does not have the right type\n")
23888 (flush *(ebp+0x10))
23889 (stop *(ebp+0x14) 1)
23890
23891
23892 $check-mu-write-to-stream-stmt:error-too-many-inouts:
23893 (write-buffered *(ebp+0x10) "fn ")
23894 8b/-> *(ebp+0xc) 0/r32/eax
23895 (lookup *eax *(eax+4))
23896 (write-buffered *(ebp+0x10) %eax)
23897 (write-buffered *(ebp+0x10) ": stmt write-to-stream: too many inouts (2 required)\n")
23898 (flush *(ebp+0x10))
23899 (stop *(ebp+0x14) 1)
23900
23901
23902 $check-mu-write-to-stream-stmt:error-unexpected-output:
23903 (write-buffered *(ebp+0x10) "fn ")
23904 8b/-> *(ebp+0xc) 0/r32/eax
23905 (lookup *eax *(eax+4))
23906 (write-buffered *(ebp+0x10) %eax)
23907 (write-buffered *(ebp+0x10) ": stmt write-to-stream: unexpected output\n")
23908 (flush *(ebp+0x10))
23909 (stop *(ebp+0x14) 1)
23910
23911
23912 check-mu-convert-stmt:
23913
23914 55/push-ebp
23915 89/<- %ebp 4/r32/esp
23916
23917 $check-mu-convert-stmt:end:
23918
23919
23920 89/<- %esp 5/r32/ebp
23921 5d/pop-to-ebp
23922 c3/return
23923
23924 check-mu-call:
23925
23926 55/push-ebp
23927 89/<- %ebp 4/r32/esp
23928
23929 68/push 0/imm32
23930
23931 81 5/subop/subtract %esp 0x60/imm32
23932 68/push 0x60/imm32/size
23933 68/push 0/imm32/read
23934 68/push 0/imm32/write
23935
23936 89/<- *(ebp-4) 4/r32/esp
23937 (clear-stream *(ebp-4))
23938
23939 50/push-eax
23940 51/push-ecx
23941 52/push-edx
23942 53/push-ebx
23943 56/push-esi
23944 57/push-edi
23945
23946 8b/-> *(ebp+8) 6/r32/esi
23947
23948 8b/-> *(ebp+0xc) 7/r32/edi
23949
23950 (lookup *(esi+0xc) *(esi+0x10))
23951 89/<- %ecx 0/r32/eax
23952
23953 (lookup *(edi+8) *(edi+0xc))
23954 89/<- %edx 0/r32/eax
23955 {
23956 $check-mu-call:check-for-inouts:
23957
23958 81 7/subop/compare %ecx 0/imm32
23959 0f 84/jump-if-= break/disp32
23960
23961 81 7/subop/compare %edx 0/imm32
23962 0f 84/jump-if-= break/disp32
23963 $check-mu-call:check-null-addr:
23964
23965 (lookup *ecx *(ecx+4))
23966 (lookup *eax *(eax+4))
23967 (string-equal? %eax "0")
23968 3d/compare-eax-and 0/imm32/false
23969 0f 85/jump-if-!= $check-mu-call:continue-to-next-inout/disp32
23970 $check-mu-call:check-inout-type:
23971
23972 (lookup *ecx *(ecx+4))
23973 (lookup *(eax+8) *(eax+0xc))
23974 89/<- %ebx 0/r32/eax
23975
23976 81 7/subop/compare *(ecx+0x10) 0/imm32/false
23977 {
23978 74/jump-if-= break/disp8
23979 (lookup *(ebx+0xc) *(ebx+0x10))
23980 89/<- %ebx 0/r32/eax
23981
23982 81 7/subop/compare *(ebx+0xc) 0/imm32
23983 75/jump-if-!= break/disp8
23984 (lookup *(ebx+4) *(ebx+8))
23985 89/<- %ebx 0/r32/eax
23986 }
23987
23988 (lookup *edx *(edx+4))
23989
23990 (lookup *(eax+8) *(eax+0xc))
23991
23992 (type-match? %eax %ebx *(ebp-4))
23993 3d/compare-eax-and 0/imm32/false
23994 {
23995 0f 85/jump-if-!= break/disp32
23996 (write-buffered *(ebp+0x14) "fn ")
23997 8b/-> *(ebp+0x10) 0/r32/eax
23998 (lookup *eax *(eax+4))
23999 (write-buffered *(ebp+0x14) %eax)
24000 (write-buffered *(ebp+0x14) ": call ")
24001 (lookup *edi *(edi+4))
24002 (write-buffered *(ebp+0x14) %eax)
24003 (write-buffered *(ebp+0x14) ": type for inout '")
24004 (lookup *ecx *(ecx+4))
24005 (lookup *eax *(eax+4))
24006 (write-buffered *(ebp+0x14) %eax)
24007 (write-buffered *(ebp+0x14) "' is not right\n")
24008 (flush *(ebp+0x14))
24009 (stop *(ebp+0x18) 1)
24010 }
24011 $check-mu-call:continue-to-next-inout:
24012
24013 (lookup *(ecx+8) *(ecx+0xc))
24014 89/<- %ecx 0/r32/eax
24015
24016 (lookup *(edx+8) *(edx+0xc))
24017 89/<- %edx 0/r32/eax
24018
24019 e9/jump loop/disp32
24020 }
24021 $check-mu-call:check-inout-count:
24022
24023 39/compare %ecx 2/r32/edx
24024 {
24025 0f 84/jump-if-= break/disp32
24026
24027
24028 {
24029 81 7/subop/compare %ecx 0/imm32
24030 0f 84/jump-if-= break/disp32
24031 (write-buffered *(ebp+0x14) "fn ")
24032 8b/-> *(ebp+0x10) 0/r32/eax
24033 (lookup *eax *(eax+4))
24034 (write-buffered *(ebp+0x14) %eax)
24035 (write-buffered *(ebp+0x14) ": call ")
24036 (lookup *edi *(edi+4))
24037 (write-buffered *(ebp+0x14) %eax)
24038 (write-buffered *(ebp+0x14) ": too many inouts\n")
24039 (flush *(ebp+0x14))
24040 (stop *(ebp+0x18) 1)
24041 }
24042
24043 {
24044 81 7/subop/compare %edx 0/imm32
24045 0f 84/jump-if-= break/disp32
24046 (write-buffered *(ebp+0x14) "fn ")
24047 8b/-> *(ebp+0x10) 0/r32/eax
24048 (lookup *eax *(eax+4))
24049 (write-buffered *(ebp+0x14) %eax)
24050 (write-buffered *(ebp+0x14) ": call ")
24051 (lookup *edi *(edi+4))
24052 (write-buffered *(ebp+0x14) %eax)
24053 (write-buffered *(ebp+0x14) ": too few inouts\n")
24054 (flush *(ebp+0x14))
24055 (stop *(ebp+0x18) 1)
24056 }
24057 }
24058 $check-mu-call:check-outputs:
24059
24060 (lookup *(esi+0x14) *(esi+0x18))
24061 89/<- %ecx 0/r32/eax
24062
24063 (lookup *(edi+0x10) *(edi+0x14))
24064 89/<- %edx 0/r32/eax
24065 {
24066 $check-mu-call:check-for-outputs:
24067
24068 81 7/subop/compare %ecx 0/imm32
24069 0f 84/jump-if-= break/disp32
24070
24071 81 7/subop/compare %edx 0/imm32
24072 0f 84/jump-if-= break/disp32
24073 $check-mu-call:check-output-type:
24074
24075 (lookup *ecx *(ecx+4))
24076
24077 (lookup *(eax+8) *(eax+0xc))
24078 89/<- %ebx 0/r32/eax
24079
24080 81 7/subop/compare *(ecx+0x10) 0/imm32/false
24081 {
24082 74/jump-if-= break/disp8
24083 (lookup *(ebx+0xc) *(ebx+0x10))
24084 89/<- %ebx 0/r32/eax
24085 }
24086
24087 (lookup *edx *(edx+4))
24088
24089 (lookup *(eax+8) *(eax+0xc))
24090
24091 (type-match? %eax %ebx *(ebp-4))
24092 3d/compare-eax-and 0/imm32/false
24093 {
24094 0f 85/jump-if-!= break/disp32
24095 (write-buffered *(ebp+0x14) "fn ")
24096 8b/-> *(ebp+0x10) 0/r32/eax
24097 (lookup *eax *(eax+4))
24098 (write-buffered *(ebp+0x14) %eax)
24099 (write-buffered *(ebp+0x14) ": call ")
24100 (lookup *edi *(edi+4))
24101 (write-buffered *(ebp+0x14) %eax)
24102 (write-buffered *(ebp+0x14) ": type for output '")
24103 (lookup *ecx *(ecx+4))
24104 (lookup *eax *(eax+4))
24105 (write-buffered *(ebp+0x14) %eax)
24106 (write-buffered *(ebp+0x14) "' is not right\n")
24107 (flush *(ebp+0x14))
24108 (stop *(ebp+0x18) 1)
24109 }
24110 $check-mu-call:check-output-register:
24111
24112 (lookup *ecx *(ecx+4))
24113
24114 (lookup *(eax+18) *(eax+0x1c))
24115 89/<- %ebx 0/r32/eax
24116
24117 3d/compare-eax-and 0/imm32
24118 {
24119 0f 85/jump-if-!= break/disp32
24120 (write-buffered *(ebp+0x14) "fn ")
24121 8b/-> *(ebp+0x10) 0/r32/eax
24122 (lookup *eax *(eax+4))
24123 (write-buffered *(ebp+0x14) %eax)
24124 (write-buffered *(ebp+0x14) ": call ")
24125 (lookup *edi *(edi+4))
24126 (write-buffered *(ebp+0x14) %eax)
24127 (write-buffered *(ebp+0x14) ": output '")
24128 (lookup *ecx *(ecx+4))
24129 (lookup *eax *(eax+4))
24130 (write-buffered *(ebp+0x14) %eax)
24131 (write-buffered *(ebp+0x14) "' is not in a register\n")
24132 (flush *(ebp+0x14))
24133 (stop *(ebp+0x18) 1)
24134 }
24135
24136 (lookup *edx *(edx+4))
24137
24138 (lookup *(eax+18) *(eax+0x1c))
24139
24140 (string-equal? %eax %ebx)
24141 3d/compare-eax-and 0/imm32/false
24142 {
24143 0f 85/jump-if-!= break/disp32
24144 (write-buffered *(ebp+0x14) "fn ")
24145 8b/-> *(ebp+0x10) 0/r32/eax
24146 (lookup *eax *(eax+4))
24147 (write-buffered *(ebp+0x14) %eax)
24148 (write-buffered *(ebp+0x14) ": call ")
24149 (lookup *edi *(edi+4))
24150 (write-buffered *(ebp+0x14) %eax)
24151 (write-buffered *(ebp+0x14) ": register for output '")
24152 (lookup *ecx *(ecx+4))
24153 (lookup *eax *(eax+4))
24154 (write-buffered *(ebp+0x14) %eax)
24155 (write-buffered *(ebp+0x14) "' is not right\n")
24156 (flush *(ebp+0x14))
24157 (stop *(ebp+0x18) 1)
24158 }
24159 $check-mu-call:continue-to-next-output:
24160
24161 (lookup *(ecx+8) *(ecx+0xc))
24162 89/<- %ecx 0/r32/eax
24163
24164 (lookup *(edx+8) *(edx+0xc))
24165 89/<- %edx 0/r32/eax
24166
24167 e9/jump loop/disp32
24168 }
24169 $check-mu-call:check-output-count:
24170
24171 39/compare %ecx 2/r32/edx
24172 {
24173 0f 84/jump-if-= break/disp32
24174
24175
24176 {
24177 81 7/subop/compare %ecx 0/imm32
24178 0f 84/jump-if-= break/disp32
24179 (write-buffered *(ebp+0x14) "fn ")
24180 8b/-> *(ebp+0x10) 0/r32/eax
24181 (lookup *eax *(eax+4))
24182 (write-buffered *(ebp+0x14) %eax)
24183 (write-buffered *(ebp+0x14) ": call ")
24184 (lookup *edi *(edi+4))
24185 (write-buffered *(ebp+0x14) %eax)
24186 (write-buffered *(ebp+0x14) ": too many outputs\n")
24187 (flush *(ebp+0x14))
24188 (stop *(ebp+0x18) 1)
24189 }
24190
24191 {
24192 81 7/subop/compare %edx 0/imm32
24193 0f 84/jump-if-= break/disp32
24194 (write-buffered *(ebp+0x14) "fn ")
24195 8b/-> *(ebp+0x10) 0/r32/eax
24196 (lookup *eax *(eax+4))
24197 (write-buffered *(ebp+0x14) %eax)
24198 (write-buffered *(ebp+0x14) ": call ")
24199 (lookup *edi *(edi+4))
24200 (write-buffered *(ebp+0x14) %eax)
24201 (write-buffered *(ebp+0x14) ": too few outputs\n")
24202 (flush *(ebp+0x14))
24203 (stop *(ebp+0x18) 1)
24204 }
24205 }
24206 $check-mu-call:end:
24207
24208 5f/pop-to-edi
24209 5e/pop-to-esi
24210 5b/pop-to-ebx
24211 5a/pop-to-edx
24212 59/pop-to-ecx
24213 58/pop-to-eax
24214
24215 81 0/subop/add %esp 0x70/imm32
24216
24217 89/<- %esp 5/r32/ebp
24218 5d/pop-to-ebp
24219 c3/return
24220
24221
24222 type-match?:
24223
24224 55/push-ebp
24225 89/<- %ebp 4/r32/esp
24226
24227 {
24228 $type-match?:check-literal-int:
24229 (is-simple-mu-type? *(ebp+0xc) 0)
24230 3d/compare-eax-and 0/imm32/false
24231 74/jump-if-= break/disp8
24232 (is-mu-numberlike-output? *(ebp+8))
24233 3d/compare-eax-and 0/imm32/false
24234 74/jump-if-= break/disp8
24235 b8/copy-to-eax 1/imm32/true
24236 e9/jump $type-match?:end/disp32
24237 }
24238
24239 {
24240 $type-match?:check-literal-string:
24241 (is-simple-mu-type? *(ebp+0xc) 0x10)
24242 3d/compare-eax-and 0/imm32/false
24243 74/jump-if-= break/disp8
24244 (is-mu-string-type? *(ebp+8))
24245 3d/compare-eax-and 0/imm32/false
24246 74/jump-if-= break/disp8
24247 b8/copy-to-eax 1/imm32/true
24248 e9/jump $type-match?:end/disp32
24249 }
24250 $type-match?:baseline:
24251
24252 (type-component-match? *(ebp+8) *(ebp+0xc) *(ebp+0x10))
24253 $type-match?:end:
24254
24255 89/<- %esp 5/r32/ebp
24256 5d/pop-to-ebp
24257 c3/return
24258
24259 type-component-match?:
24260
24261 55/push-ebp
24262 89/<- %ebp 4/r32/esp
24263
24264 51/push-ecx
24265 52/push-edx
24266 53/push-ebx
24267
24268 8b/-> *(ebp+8) 1/r32/ecx
24269
24270 8b/-> *(ebp+0xc) 2/r32/edx
24271 $type-component-match?:compare-addr:
24272
24273 8b/-> %ecx 0/r32/eax
24274 39/compare %edx 0/r32/eax
24275 b8/copy-to-eax 1/imm32/true
24276 0f 84/jump-if-= $type-component-match?:end/disp32
24277
24278 b8/copy-to-eax 0/imm32/false
24279 81 7/subop/compare %ecx 0/imm32
24280 0f 84/jump-if-= $type-component-match?:end/disp32
24281
24282 81 7/subop/compare %edx 0/imm32
24283 0f 84/jump-if-= $type-component-match?:end/disp32
24284
24285 {
24286 $type-component-match?:check-type-parameter:
24287 81 7/subop/compare *ecx 0/imm32/false
24288 74/jump-if-= break/disp8
24289 81 7/subop/compare *(ecx+4) 0xa/imm32/type-parameter
24290 75/jump-if-!= break/disp8
24291 $type-component-match?:type-parameter:
24292 (type-parameter-match? *(ecx+8) *(ecx+0xc) %edx *(ebp+0x10))
24293 e9/jump $type-component-match?:end/disp32
24294 }
24295
24296 {
24297 $type-component-match?:check-list-type-parameter:
24298
24299 81 7/subop/compare *ecx 0/imm32/false
24300 75/jump-if-!= break/disp8
24301
24302 81 7/subop/compare *(ecx+0xc) 0/imm32
24303 75/jump-if-!= break/disp8
24304
24305 (lookup *(ecx+4) *(ecx+8))
24306 81 7/subop/compare *eax 0/imm32/false
24307 74/jump-if-= break/disp8
24308 81 7/subop/compare *(eax+4) 0xa/imm32/type-parameter
24309 75/jump-if-!= break/disp8
24310 $type-component-match?:list-type-parameter:
24311 (type-parameter-match? *(eax+8) *(eax+0xc) %edx *(ebp+0x10))
24312 e9/jump $type-component-match?:end/disp32
24313 }
24314 $type-component-match?:compare-atom-state:
24315
24316 8b/-> *ecx 3/r32/ebx
24317 39/compare *edx 3/r32/ebx
24318 b8/copy-to-eax 0/imm32/false
24319 0f 85/jump-if-!= $type-component-match?:end/disp32
24320
24321 {
24322 $type-component-match?:check-atom:
24323 81 7/subop/compare %ebx 0/imm32/false
24324 74/jump-if-= break/disp8
24325 $type-component-match?:is-atom:
24326 8b/-> *(ecx+4) 0/r32/eax
24327 39/compare *(edx+4) 0/r32/eax
24328 0f 94/set-if-= %al
24329 81 4/subop/and %eax 0xff/imm32
24330 e9/jump $type-component-match?:end/disp32
24331 }
24332 $type-component-match?:check-left:
24333
24334 (lookup *(ecx+4) *(ecx+8))
24335 89/<- %ebx 0/r32/eax
24336 (lookup *(edx+4) *(edx+8))
24337 (type-component-match? %ebx %eax *(ebp+0x10))
24338 3d/compare-eax-and 0/imm32/false
24339 74/jump-if-= $type-component-match?:end/disp8
24340 $type-component-match?:check-right:
24341
24342 (lookup *(ecx+0xc) *(ecx+0x10))
24343 89/<- %ebx 0/r32/eax
24344 (lookup *(edx+0xc) *(edx+0x10))
24345 (type-component-match? %ebx %eax *(ebp+0x10))
24346 $type-component-match?:end:
24347
24348 5b/pop-to-ebx
24349 5a/pop-to-edx
24350 59/pop-to-ecx
24351
24352 89/<- %esp 5/r32/ebp
24353 5d/pop-to-ebp
24354 c3/return
24355
24356 type-parameter-match?:
24357
24358 55/push-ebp
24359 89/<- %ebp 4/r32/esp
24360
24361 51/push-ecx
24362
24363 (get-or-insert-handle *(ebp+0x14) *(ebp+8) *(ebp+0xc) 0xc)
24364
24365 {
24366 81 7/subop/compare *eax 0/imm32
24367 75/jump-if-!= break/disp8
24368 8b/-> *(ebp+0x10) 1/r32/ecx
24369 89/<- *eax 1/r32/ecx
24370 }
24371
24372 (type-equal? *(ebp+0x10) *eax)
24373 $type-parameter-match?:end:
24374
24375 59/pop-to-ecx
24376
24377 89/<- %esp 5/r32/ebp
24378 5d/pop-to-ebp
24379 c3/return
24380
24381 size-of:
24382
24383 55/push-ebp
24384 89/<- %ebp 4/r32/esp
24385
24386 51/push-ecx
24387
24388 8b/-> *(ebp+8) 1/r32/ecx
24389
24390
24391
24392
24393
24394
24395
24396 (lookup *(ecx+8) *(ecx+0xc))
24397 89/<- %ecx 0/r32/eax
24398
24399 {
24400 (is-mu-array? %ecx)
24401 3d/compare-eax-and 0/imm32/false
24402 74/jump-if-= break/disp8
24403 (size-of-array %ecx)
24404 eb/jump $size-of:end/disp8
24405 }
24406
24407 {
24408 (is-mu-stream? %ecx)
24409 3d/compare-eax-and 0/imm32/false
24410 74/jump-if-= break/disp8
24411 (size-of-stream %ecx)
24412 eb/jump $size-of:end/disp8
24413 }
24414
24415 {
24416 81 7/subop/compare *ecx 0/imm32/false
24417 75/jump-if-!= break/disp8
24418 (lookup *(ecx+4) *(ecx+8))
24419 89/<- %ecx 0/r32/eax
24420 }
24421
24422 (size-of-type-id *(ecx+4))
24423 $size-of:end:
24424
24425 59/pop-to-ecx
24426
24427 89/<- %esp 5/r32/ebp
24428 5d/pop-to-ebp
24429 c3/return
24430
24431 size-of-deref:
24432
24433 55/push-ebp
24434 89/<- %ebp 4/r32/esp
24435
24436 51/push-ecx
24437
24438 8b/-> *(ebp+8) 1/r32/ecx
24439 (lookup *(ecx+8) *(ecx+0xc))
24440 89/<- %ecx 0/r32/eax
24441
24442
24443 (lookup *(ecx+0xc) *(ecx+0x10))
24444 89/<- %ecx 0/r32/eax
24445
24446 {
24447 (is-mu-array? %ecx)
24448 3d/compare-eax-and 0/imm32/false
24449 74/jump-if-= break/disp8
24450 (size-of-array %ecx)
24451 eb/jump $size-of-deref:end/disp8
24452 }
24453
24454 {
24455 (is-mu-stream? %ecx)
24456 3d/compare-eax-and 0/imm32/false
24457 74/jump-if-= break/disp8
24458 (size-of-stream %ecx)
24459 eb/jump $size-of-deref:end/disp8
24460 }
24461
24462 {
24463 81 7/subop/compare *ecx 0/imm32/false
24464 75/jump-if-!= break/disp8
24465 (lookup *(ecx+4) *(ecx+8))
24466 89/<- %ecx 0/r32/eax
24467 }
24468
24469 (size-of-type-id *(ecx+4))
24470 $size-of-deref:end:
24471
24472 59/pop-to-ecx
24473
24474 89/<- %esp 5/r32/ebp
24475 5d/pop-to-ebp
24476 c3/return
24477
24478 is-mu-array?:
24479
24480 55/push-ebp
24481 89/<- %ebp 4/r32/esp
24482
24483 51/push-ecx
24484
24485 8b/-> *(ebp+8) 1/r32/ecx
24486
24487 81 7/subop/compare *ecx 0/imm32/false
24488 75/jump-if-!= $is-mu-array?:return-false/disp8
24489
24490 (lookup *(ecx+4) *(ecx+8))
24491 81 7/subop/compare *eax 0/imm32/false
24492 74/jump-if-= $is-mu-array?:return-false/disp8
24493
24494 81 7/subop/compare *(eax+4) 3/imm32/array-type-id
24495 0f 94/set-if-= %al
24496 81 4/subop/and %eax 0xff/imm32
24497 eb/jump $is-mu-array?:end/disp8
24498 $is-mu-array?:return-false:
24499 b8/copy-to-eax 0/imm32/false
24500 $is-mu-array?:end:
24501
24502 59/pop-to-ecx
24503
24504 89/<- %esp 5/r32/ebp
24505 5d/pop-to-ebp
24506 c3/return
24507
24508
24509 size-of-array:
24510
24511 55/push-ebp
24512 89/<- %ebp 4/r32/esp
24513
24514 51/push-ecx
24515 52/push-edx
24516
24517 8b/-> *(ebp+8) 1/r32/ecx
24518
24519 (lookup *(ecx+0xc) *(ecx+0x10))
24520 89/<- %ecx 0/r32/eax
24521
24522 (lookup *(ecx+4) *(ecx+8))
24523 8b/-> *(eax+4) 2/r32/edx
24524
24525
24526 (lookup *(ecx+0xc) *(ecx+0x10))
24527 (lookup *(eax+4) *(eax+8))
24528 8b/-> *(eax+8) 1/r32/ecx
24529
24530 (size-of-type-id-as-array-element %edx)
24531 f7 4/subop/multiply-into-edx-eax %ecx
24532 05/add-to-eax 4/imm32
24533
24534 $size-of-array:end:
24535
24536 5a/pop-to-edx
24537 59/pop-to-ecx
24538
24539 89/<- %esp 5/r32/ebp
24540 5d/pop-to-ebp
24541 c3/return
24542
24543 is-mu-stream?:
24544
24545 55/push-ebp
24546 89/<- %ebp 4/r32/esp
24547
24548 51/push-ecx
24549
24550 8b/-> *(ebp+8) 1/r32/ecx
24551
24552 81 7/subop/compare *ecx 0/imm32/false
24553 75/jump-if-!= $is-mu-stream?:return-false/disp8
24554
24555 (lookup *(ecx+4) *(ecx+8))
24556 81 7/subop/compare *eax 0/imm32/false
24557 74/jump-if-= $is-mu-stream?:return-false/disp8
24558
24559 81 7/subop/compare *(eax+4) 0xb/imm32/stream-type-id
24560 0f 94/set-if-= %al
24561 81 4/subop/and %eax 0xff/imm32
24562 eb/jump $is-mu-stream?:end/disp8
24563 $is-mu-stream?:return-false:
24564 b8/copy-to-eax 0/imm32/false
24565 $is-mu-stream?:end:
24566
24567 59/pop-to-ecx
24568
24569 89/<- %esp 5/r32/ebp
24570 5d/pop-to-ebp
24571 c3/return
24572
24573
24574 size-of-stream:
24575
24576 55/push-ebp
24577 89/<- %ebp 4/r32/esp
24578
24579 (size-of-array *(ebp+8))
24580 05/add-to-eax 8/imm32
24581 $size-of-stream:end:
24582
24583 89/<- %esp 5/r32/ebp
24584 5d/pop-to-ebp
24585 c3/return
24586
24587 size-of-type-id:
24588
24589 55/push-ebp
24590 89/<- %ebp 4/r32/esp
24591
24592 51/push-ecx
24593
24594 68/push 0/imm32
24595 68/push 0/imm32
24596 89/<- %ecx 4/r32/esp
24597
24598 8b/-> *(ebp+8) 0/r32/eax
24599
24600 3d/compare-eax-and 0/imm32
24601 0f 84/jump-if-= $size-of-type-id:end/disp32
24602
24603 3d/compare-eax-and 8/imm32/byte
24604 {
24605 75/jump-if-!= break/disp8
24606 b8/copy-to-eax 4/imm32
24607 eb/jump $size-of-type-id:end/disp8
24608 }
24609
24610 3d/compare-eax-and 4/imm32/handle
24611 {
24612 75/jump-if-!= break/disp8
24613 b8/copy-to-eax 8/imm32
24614 eb/jump $size-of-type-id:end/disp8
24615 }
24616
24617 3d/compare-eax-and 0xc/imm32/slice
24618 {
24619 75/jump-if-!= break/disp8
24620 b8/copy-to-eax 8/imm32
24621 eb/jump $size-of-type-id:end/disp8
24622 }
24623
24624
24625 (find-typeinfo %eax %ecx)
24626 {
24627 81 7/subop/compare *ecx 0/imm32
24628 74/jump-if-= break/disp8
24629 $size-of-type-id:user-defined:
24630 (lookup *ecx *(ecx+4))
24631 8b/-> *(eax+0xc) 0/r32/eax
24632 eb/jump $size-of-type-id:end/disp8
24633 }
24634
24635 b8/copy-to-eax 4/imm32
24636 $size-of-type-id:end:
24637
24638 81 0/subop/add %esp 8/imm32
24639
24640 59/pop-to-ecx
24641
24642 89/<- %esp 5/r32/ebp
24643 5d/pop-to-ebp
24644 c3/return
24645
24646
24647
24648
24649 type-tail:
24650
24651 55/push-ebp
24652 89/<- %ebp 4/r32/esp
24653
24654 51/push-ecx
24655
24656 b8/copy-to-eax 0/imm32
24657
24658 8b/-> *(ebp+8) 1/r32/ecx
24659 $type-tail:check-atom:
24660
24661 81 7/subop/compare *ecx 0/imm32/false
24662 0f 85/jump-if-!= $type-tail:end/disp32
24663
24664 (lookup *(ecx+0xc) *(ecx+0x10))
24665 89/<- %ecx 0/r32/eax
24666 $type-tail:check-singleton:
24667
24668 {
24669 81 7/subop/compare *(ecx+0xc) 0/imm32
24670 75/jump-if-!= break/disp8
24671 (lookup *(ecx+4) *(ecx+8))
24672 e9/jump $type-tail:end/disp32
24673 }
24674
24675 {
24676 $type-tail:check-array-capacity:
24677 (lookup *(ecx+0xc) *(ecx+0x10))
24678 81 7/subop/compare *eax 0/imm32/false
24679 75/jump-if-!= break/disp8
24680 $type-tail:check-array-capacity-1:
24681 (lookup *(eax+4) *(eax+8))
24682 3d/compare-eax-and 0/imm32
24683 74/jump-if-= break/disp8
24684 $type-tail:check-array-capacity-2:
24685 (is-simple-mu-type? %eax 9)
24686 3d/compare-eax-and 0/imm32/false
24687 74/jump-if-= break/disp8
24688 $type-tail:array-capacity:
24689 (lookup *(ecx+4) *(ecx+8))
24690 eb/jump $type-tail:end/disp8
24691 }
24692 $type-tail:check-compound-left:
24693
24694 (lookup *(ecx+4) *(ecx+8))
24695 81 7/subop/compare *eax 0/imm32/false
24696 74/jump-if-= $type-tail:end/disp8
24697 $type-tail:return-tail:
24698
24699 89/<- %eax 1/r32/ecx
24700 $type-tail:end:
24701
24702 59/pop-to-ecx
24703
24704 89/<- %esp 5/r32/ebp
24705 5d/pop-to-ebp
24706 c3/return
24707
24708 type-equal?:
24709
24710 55/push-ebp
24711 89/<- %ebp 4/r32/esp
24712
24713 51/push-ecx
24714 52/push-edx
24715 53/push-ebx
24716
24717 8b/-> *(ebp+8) 1/r32/ecx
24718
24719 8b/-> *(ebp+0xc) 2/r32/edx
24720 $type-equal?:compare-addr:
24721
24722 8b/-> %ecx 0/r32/eax
24723 39/compare %edx 0/r32/eax
24724 b8/copy-to-eax 1/imm32/true
24725 0f 84/jump-if-= $type-equal?:end/disp32
24726 $type-equal?:compare-null-a:
24727
24728 b8/copy-to-eax 0/imm32/false
24729 81 7/subop/compare %ecx 0/imm32
24730 0f 84/jump-if-= $type-equal?:end/disp32
24731 $type-equal?:compare-null-b:
24732
24733 81 7/subop/compare %edx 0/imm32
24734 0f 84/jump-if-= $type-equal?:end/disp32
24735 $type-equal?:compare-atom-state:
24736
24737 8b/-> *ecx 3/r32/ebx
24738 39/compare *edx 3/r32/ebx
24739 b8/copy-to-eax 0/imm32/false
24740 0f 85/jump-if-!= $type-equal?:end/disp32
24741
24742 {
24743 $type-equal?:check-atom:
24744 81 7/subop/compare %ebx 0/imm32/false
24745 74/jump-if-= break/disp8
24746 $type-equal?:is-atom:
24747 8b/-> *(ecx+4) 0/r32/eax
24748 39/compare *(edx+4) 0/r32/eax
24749 0f 94/set-if-= %al
24750 81 4/subop/and %eax 0xff/imm32
24751 e9/jump $type-equal?:end/disp32
24752 }
24753 $type-equal?:check-left:
24754
24755 (lookup *(ecx+4) *(ecx+8))
24756 89/<- %ebx 0/r32/eax
24757 (lookup *(edx+4) *(edx+8))
24758 (type-equal? %eax %ebx)
24759 3d/compare-eax-and 0/imm32/false
24760 74/jump-if-= $type-equal?:end/disp8
24761 $type-equal?:check-right:
24762
24763 (lookup *(ecx+0xc) *(ecx+0x10))
24764 89/<- %ebx 0/r32/eax
24765 (lookup *(edx+0xc) *(edx+0x10))
24766 (type-equal? %eax %ebx)
24767 $type-equal?:end:
24768
24769 5b/pop-to-ebx
24770 5a/pop-to-edx
24771 59/pop-to-ecx
24772
24773 89/<- %esp 5/r32/ebp
24774 5d/pop-to-ebp
24775 c3/return
24776
24777
24778
24779
24780
24781 == data
24782
24783
24784 Curr-local-stack-offset:
24785 0/imm32
24786
24787 == code
24788
24789
24790
24791
24792
24793
24794 emit-subx:
24795
24796 55/push-ebp
24797 89/<- %ebp 4/r32/esp
24798
24799 50/push-eax
24800
24801 (lookup *_Program-functions *_Program-functions->payload)
24802 {
24803
24804 3d/compare-eax-and 0/imm32
24805 0f 84/jump-if-= break/disp32
24806 (emit-subx-function *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10))
24807
24808 (lookup *(eax+0x20) *(eax+0x24))
24809 e9/jump loop/disp32
24810 }
24811 $emit-subx:end:
24812
24813 58/pop-to-eax
24814
24815 89/<- %esp 5/r32/ebp
24816 5d/pop-to-ebp
24817 c3/return
24818
24819 emit-subx-function:
24820
24821 55/push-ebp
24822 89/<- %ebp 4/r32/esp
24823
24824 (populate-mu-type-offsets-in-inouts *(ebp+0xc))
24825
24826 50/push-eax
24827 51/push-ecx
24828 52/push-edx
24829
24830 c7 0/subop/copy *Curr-block-depth 1/imm32
24831 c7 0/subop/copy *Curr-local-stack-offset 0/imm32
24832
24833 8b/-> *(ebp+0xc) 1/r32/ecx
24834
24835 81 5/subop/subtract %esp 0xc00/imm32
24836 68/push 0xc00/imm32/size
24837 68/push 0/imm32/top
24838 89/<- %edx 4/r32/esp
24839
24840 (lookup *ecx *(ecx+4))
24841
24842 (write-buffered *(ebp+8) %eax)
24843 (write-buffered *(ebp+8) ":\n")
24844 (emit-subx-prologue *(ebp+8))
24845
24846 (lookup *(ecx+0x18) *(ecx+0x1c))
24847
24848 (emit-subx-block *(ebp+8) %eax %edx *(ebp+0xc) *(ebp+0x10) *(ebp+0x14))
24849 (emit-subx-epilogue *(ebp+8))
24850
24851
24852 $emit-subx-function:end:
24853
24854 81 0/subop/add %esp 0xc08/imm32
24855
24856 5a/pop-to-edx
24857 59/pop-to-ecx
24858 58/pop-to-eax
24859
24860 89/<- %esp 5/r32/ebp
24861 5d/pop-to-ebp
24862 c3/return
24863
24864 populate-mu-type-offsets-in-inouts:
24865
24866 55/push-ebp
24867 89/<- %ebp 4/r32/esp
24868
24869 50/push-eax
24870 51/push-ecx
24871 52/push-edx
24872 53/push-ebx
24873 57/push-edi
24874
24875 ba/copy-to-edx 8/imm32
24876
24877 8b/-> *(ebp+8) 1/r32/ecx
24878 (lookup *(ecx+8) *(ecx+0xc))
24879 89/<- %ecx 0/r32/eax
24880 {
24881 $populate-mu-type-offsets-in-inouts:loop:
24882 81 7/subop/compare %ecx 0/imm32
24883 74/jump-if-= break/disp8
24884
24885 (lookup *ecx *(ecx+4))
24886 89/<- %ebx 0/r32/eax
24887
24888
24889
24890
24891
24892
24893
24894
24895
24896
24897 89/<- *(ebx+0x14) 2/r32/edx
24898
24899 (size-of %ebx)
24900 01/add-to %edx 0/r32/eax
24901
24902 (lookup *(ecx+8) *(ecx+0xc))
24903 89/<- %ecx 0/r32/eax
24904
24905 eb/jump loop/disp8
24906 }
24907 $populate-mu-type-offsets-in-inouts:end:
24908
24909 5f/pop-to-edi
24910 5b/pop-to-ebx
24911 5a/pop-to-edx
24912 59/pop-to-ecx
24913 58/pop-to-eax
24914
24915 89/<- %esp 5/r32/ebp
24916 5d/pop-to-ebp
24917 c3/return
24918
24919 emit-subx-stmt-list:
24920
24921 55/push-ebp
24922 89/<- %ebp 4/r32/esp
24923
24924 50/push-eax
24925 51/push-ecx
24926 53/push-ebx
24927 56/push-esi
24928
24929 8b/-> *(ebp+0xc) 6/r32/esi
24930
24931 {
24932 $emit-subx-stmt-list:loop:
24933 81 7/subop/compare %esi 0/imm32
24934 0f 84/jump-if-= break/disp32
24935
24936 (lookup *esi *(esi+4))
24937 89/<- %ecx 0/r32/eax
24938 {
24939 $emit-subx-stmt-list:check-for-block:
24940 81 7/subop/compare *ecx 0/imm32/block
24941 75/jump-if-!= break/disp8
24942 $emit-subx-stmt-list:block:
24943 (emit-subx-block *(ebp+8) %ecx *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c))
24944 }
24945 {
24946 $emit-subx-stmt-list:check-for-stmt:
24947 81 7/subop/compare *ecx 1/imm32/stmt1
24948 0f 85/jump-if-!= break/disp32
24949 $emit-subx-stmt-list:stmt1:
24950 {
24951 (is-mu-branch? %ecx)
24952 3d/compare-eax-and 0/imm32/false
24953 0f 84/jump-if-= break/disp32
24954 $emit-subx-stmt-list:branch-stmt:
24955 +-- 25 lines: # unconditional return -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
24980 +-- 27 lines: # unconditional loops --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
25007 +-- 16 lines: # unconditional breaks -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
25023 +-- 38 lines: # simple conditional branches without a target -------------------------------------------------------------------------------------------------------------------------------------------------------
25061 +-- 19 lines: # conditional branches with an explicit target -------------------------------------------------------------------------------------------------------------------------------------------------------
25080 }
25081 $emit-subx-stmt-list:1-to-1:
25082 (emit-subx-stmt *(ebp+8) %ecx Primitives *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c))
25083 e9/jump $emit-subx-stmt-list:continue/disp32
25084 }
25085 {
25086 $emit-subx-stmt-list:check-for-var-def:
25087 81 7/subop/compare *ecx 2/imm32/var-def
25088 75/jump-if-!= break/disp8
25089 $emit-subx-stmt-list:var-def:
25090 (emit-subx-var-def *(ebp+8) %ecx)
25091 (push *(ebp+0x10) *(ecx+4))
25092 (push *(ebp+0x10) *(ecx+8))
25093 (push *(ebp+0x10) 0)
25094
25095 eb/jump $emit-subx-stmt-list:continue/disp8
25096 }
25097 {
25098 $emit-subx-stmt-list:check-for-reg-var-def:
25099 81 7/subop/compare *ecx 3/imm32/reg-var-def
25100 0f 85/jump-if-!= break/disp32
25101 $emit-subx-stmt-list:reg-var-def:
25102
25103 (push-output-and-maybe-emit-spill *(ebp+8) %ecx *(ebp+0x10) %esi *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c))
25104
25105 (emit-subx-stmt *(ebp+8) %ecx Primitives *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c))
25106
25107 eb/jump $emit-subx-stmt-list:continue/disp8
25108 }
25109 $emit-subx-stmt-list:continue:
25110
25111 (lookup *(esi+8) *(esi+0xc))
25112 89/<- %esi 0/r32/eax
25113 e9/jump loop/disp32
25114 }
25115 $emit-subx-stmt-list:emit-cleanup:
25116 (emit-cleanup-code-until-depth *(ebp+8) *(ebp+0x10) *Curr-block-depth)
25117 $emit-subx-stmt-list:clean-up:
25118 (clean-up-stack-offset-state *(ebp+0x10) *Curr-block-depth)
25119 (clean-up-blocks *(ebp+0x10) *Curr-block-depth *(ebp+0x14))
25120 $emit-subx-stmt-list:end:
25121
25122 5e/pop-to-esi
25123 5b/pop-to-ebx
25124 59/pop-to-ecx
25125 58/pop-to-eax
25126
25127 89/<- %esp 5/r32/ebp
25128 5d/pop-to-ebp
25129 c3/return
25130
25131
25132 push-output-and-maybe-emit-spill:
25133
25134 55/push-ebp
25135 89/<- %ebp 4/r32/esp
25136
25137 50/push-eax
25138 51/push-ecx
25139 52/push-edx
25140
25141 8b/-> *(ebp+0xc) 1/r32/ecx
25142
25143 (lookup *(ecx+0x14) *(ecx+0x18))
25144
25145
25146 (lookup *eax *(eax+4))
25147 89/<- %ecx 0/r32/eax
25148
25149 8b/-> *Curr-block-depth 0/r32/eax
25150 89/<- *(ecx+0x10) 0/r32/eax
25151
25152
25153
25154
25155
25156
25157
25158
25159 81 7/subop/compare *(ecx+0x18) 0/imm32
25160 0f 84/jump-if-= $push-output-and-maybe-emit-spill:abort/disp32
25161
25162 (not-yet-spilled-this-block? %ecx *(ebp+0x10))
25163 89/<- %edx 0/r32/eax
25164 3d/compare-eax-and 0/imm32/false
25165 0f 84/jump-if-= $push-output-and-maybe-emit-spill:push/disp32
25166 (will-not-write-some-register? %ecx *(ebp+0x14) *(ebp+0x18))
25167 89/<- %edx 0/r32/eax
25168
25169 3d/compare-eax-and 0/imm32/false
25170 0f 84/jump-if-= $push-output-and-maybe-emit-spill:push/disp32
25171
25172
25173 81 5/subop/subtract *Curr-local-stack-offset 4/imm32
25174
25175 (lookup *(ecx+0x18) *(ecx+0x1c))
25176 (emit-push-register *(ebp+8) %eax)
25177 $push-output-and-maybe-emit-spill:push:
25178 8b/-> *(ebp+0xc) 1/r32/ecx
25179 (lookup *(ecx+0x14) *(ecx+0x18))
25180
25181 (push *(ebp+0x10) *eax)
25182 (push *(ebp+0x10) *(eax+4))
25183 (push *(ebp+0x10) %edx)
25184 $push-output-and-maybe-emit-spill:end:
25185
25186 5a/pop-to-edx
25187 59/pop-to-ecx
25188 58/pop-to-eax
25189
25190 89/<- %esp 5/r32/ebp
25191 5d/pop-to-ebp
25192 c3/return
25193
25194 $push-output-and-maybe-emit-spill:abort:
25195
25196 (write-buffered *(ebp+0x1c) "var '")
25197 (write-buffered *(ebp+0x1c) *eax)
25198 (write-buffered *(ebp+0x1c) "' initialized from an instruction must live in a register\n")
25199 (flush *(ebp+0x1c))
25200 (stop *(ebp+0x20) 1)
25201
25202
25203 emit-subx-cleanup-and-unconditional-nonlocal-branch:
25204
25205 55/push-ebp
25206 89/<- %ebp 4/r32/esp
25207
25208 50/push-eax
25209 51/push-ecx
25210
25211 8b/-> *(ebp+0xc) 1/r32/ecx
25212
25213 (lookup *(ecx+0xc) *(ecx+0x10))
25214 (lookup *eax *(eax+4))
25215 (lookup *eax *(eax+4))
25216
25217 (emit-cleanup-code-until-target *(ebp+8) *(ebp+0x10) %eax)
25218
25219 (emit-indent *(ebp+8) *Curr-block-depth)
25220 (write-buffered *(ebp+8) "e9/jump ")
25221 (write-buffered *(ebp+8) %eax)
25222 (lookup *(ecx+4) *(ecx+8))
25223 (string-starts-with? %eax "break")
25224 3d/compare-eax-and 0/imm32/false
25225 {
25226 74/jump-if-= break/disp8
25227 (write-buffered *(ebp+8) ":break/disp32\n")
25228 eb/jump $emit-subx-cleanup-and-unconditional-nonlocal-branch:end/disp8
25229 }
25230 (write-buffered *(ebp+8) ":loop/disp32\n")
25231 $emit-subx-cleanup-and-unconditional-nonlocal-branch:end:
25232
25233 59/pop-to-ecx
25234 58/pop-to-eax
25235
25236 89/<- %esp 5/r32/ebp
25237 5d/pop-to-ebp
25238 c3/return
25239
25240 emit-outputs:
25241
25242
25243
25244
25245
25246
25247
25248
25249 55/push-ebp
25250 89/<- %ebp 4/r32/esp
25251
25252 50/push-eax
25253 51/push-ecx
25254 56/push-esi
25255 57/push-edi
25256
25257 8b/-> *(ebp+0xc) 0/r32/eax
25258 (lookup *(eax+0xc) *(eax+0x10))
25259 89/<- %esi 0/r32/eax
25260
25261 8b/-> *(ebp+0x10) 0/r32/eax
25262 (lookup *(eax+0x10) *(eax+0x14))
25263 89/<- %edi 0/r32/eax
25264 {
25265 $emit-outputs:loop:
25266 81 7/subop/compare %esi 0/imm32
25267 0f 84/jump-if-= break/disp32
25268
25269
25270 (lookup *esi *(esi+4))
25271 89/<- %ecx 0/r32/eax
25272
25273 (lookup *(ecx+8) *(ecx+0xc))
25274 (is-simple-mu-type? %eax 0)
25275 {
25276 3d/compare-eax-and 0/imm32/false
25277 0f 84/jump-if-= break/disp32
25278 (emit-indent *(ebp+8) *Curr-block-depth)
25279 (write-buffered *(ebp+8) "c7 0/subop/copy %")
25280 (lookup *edi *(edi+4))
25281 (lookup *(eax+0x18) *(eax+0x1c))
25282 (write-buffered *(ebp+8) %eax)
25283 (write-buffered *(ebp+8) " ")
25284 (lookup *ecx *(ecx+4))
25285 (write-buffered *(ebp+8) %eax)
25286 (write-buffered *(ebp+8) "/imm32\n")
25287 e9/jump $emit-outputs:continue/disp32
25288 }
25289
25290 (lookup *(ecx+0x18) *(ecx+0x1c))
25291 {
25292 3d/compare-eax-and 0/imm32
25293 0f 84/jump-if-= break/disp32
25294 8a/copy-byte *(eax+4) 0/r32/AL
25295 81 4/subop/and %eax 0xff/imm32
25296 3d/compare-eax-and 0x78/imm32/x
25297 0f 85/jump-if-!= break/disp32
25298 (emit-indent *(ebp+8) *Curr-block-depth)
25299 (write-buffered *(ebp+8) "f3 0f 10/->")
25300 (emit-subx-var-as-rm32 *(ebp+8) %esi)
25301 (write-buffered *(ebp+8) " ")
25302 (lookup *edi *(edi+4))
25303 (lookup *(eax+0x18) *(eax+0x1c))
25304 (get Mu-registers %eax 0xc "Mu-registers")
25305 (write-int32-hex-buffered *(ebp+8) *eax)
25306 (write-buffered *(ebp+8) "/x32\n")
25307 e9/jump $emit-outputs:continue/disp32
25308 }
25309
25310 (emit-indent *(ebp+8) *Curr-block-depth)
25311 (write-buffered *(ebp+8) "8b/->")
25312 (emit-subx-var-as-rm32 *(ebp+8) %esi)
25313 (write-buffered *(ebp+8) " ")
25314 (lookup *edi *(edi+4))
25315 (lookup *(eax+0x18) *(eax+0x1c))
25316 (get Mu-registers %eax 0xc "Mu-registers")
25317 (write-int32-hex-buffered *(ebp+8) *eax)
25318 (write-buffered *(ebp+8) "/r32\n")
25319 $emit-outputs:continue:
25320
25321 (lookup *(esi+8) *(esi+0xc))
25322 89/<- %esi 0/r32/eax
25323
25324 (lookup *(edi+8) *(edi+0xc))
25325 89/<- %edi 0/r32/eax
25326
25327 e9/jump loop/disp32
25328 }
25329 $emit-outputs:end:
25330
25331 5f/pop-to-edi
25332 5e/pop-to-esi
25333 59/pop-to-ecx
25334 58/pop-to-eax
25335
25336 89/<- %esp 5/r32/ebp
25337 5d/pop-to-ebp
25338 c3/return
25339
25340 is-mu-branch?:
25341
25342 55/push-ebp
25343 89/<- %ebp 4/r32/esp
25344
25345 51/push-ecx
25346
25347 8b/-> *(ebp+8) 1/r32/ecx
25348 (lookup *(ecx+4) *(ecx+8))
25349 89/<- %ecx 0/r32/eax
25350
25351 (string-starts-with? %ecx "loop")
25352 3d/compare-eax-and 0/imm32/false
25353 75/jump-if-not-equal $is-mu-branch?:end/disp8
25354
25355 (string-starts-with? %ecx "break")
25356 3d/compare-eax-and 0/imm32/false
25357 75/jump-if-not-equal $is-mu-branch?:end/disp8
25358
25359 (string-starts-with? %ecx "return")
25360 $is-mu-branch?:end:
25361
25362 59/pop-to-ecx
25363
25364 89/<- %esp 5/r32/ebp
25365 5d/pop-to-ebp
25366 c3/return
25367
25368 emit-reverse-break:
25369
25370 55/push-ebp
25371 89/<- %ebp 4/r32/esp
25372
25373 50/push-eax
25374
25375 8b/-> *(ebp+0xc) 0/r32/eax
25376
25377 (lookup *(eax+4) *(eax+8))
25378 (get Reverse-branch %eax 0x10 "reverse-branch: ")
25379 (emit-indent *(ebp+8) *Curr-block-depth)
25380 (lookup *eax *(eax+4))
25381 (write-buffered *(ebp+8) %eax)
25382 (write-buffered *(ebp+8) " break/disp32\n")
25383 $emit-reverse-break:end:
25384
25385 58/pop-to-eax
25386
25387 89/<- %esp 5/r32/ebp
25388 5d/pop-to-ebp
25389 c3/return
25390
25391 == data
25392
25393
25394 Reverse-branch:
25395
25396 0x1c0/imm32/write
25397 0/imm32/read
25398 0x1c0/imm32/size
25399
25400 0x11/imm32/alloc-id _string-break-if-=/imm32 0x11/imm32/alloc-id _string_0f_85_jump_label/imm32
25401 0x11/imm32/alloc-id _string-loop-if-=/imm32 0x11/imm32/alloc-id _string_0f_85_jump_label/imm32
25402 0x11/imm32/alloc-id _string-break-if-!=/imm32 0x11/imm32/alloc-id _string_0f_84_jump_label/imm32
25403 0x11/imm32/alloc-id _string-loop-if-!=/imm32 0x11/imm32/alloc-id _string_0f_84_jump_label/imm32
25404 0x11/imm32/alloc-id _string-break-if-</imm32 0x11/imm32/alloc-id _string_0f_8d_jump_label/imm32
25405 0x11/imm32/alloc-id _string-loop-if-</imm32 0x11/imm32/alloc-id _string_0f_8d_jump_label/imm32
25406 0x11/imm32/alloc-id _string-break-if->/imm32 0x11/imm32/alloc-id _string_0f_8e_jump_label/imm32
25407 0x11/imm32/alloc-id _string-loop-if->/imm32 0x11/imm32/alloc-id _string_0f_8e_jump_label/imm32
25408 0x11/imm32/alloc-id _string-break-if-<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32
25409 0x11/imm32/alloc-id _string-loop-if-<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32
25410 0x11/imm32/alloc-id _string-break-if->=/imm32 0x11/imm32/alloc-id _string_0f_8c_jump_label/imm32
25411 0x11/imm32/alloc-id _string-loop-if->=/imm32 0x11/imm32/alloc-id _string_0f_8c_jump_label/imm32
25412 0x11/imm32/alloc-id _string-break-if-addr</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32
25413 0x11/imm32/alloc-id _string-loop-if-addr</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32
25414 0x11/imm32/alloc-id _string-break-if-addr>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32
25415 0x11/imm32/alloc-id _string-loop-if-addr>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32
25416 0x11/imm32/alloc-id _string-break-if-addr<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32
25417 0x11/imm32/alloc-id _string-loop-if-addr<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32
25418 0x11/imm32/alloc-id _string-break-if-addr>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32
25419 0x11/imm32/alloc-id _string-loop-if-addr>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32
25420 0x11/imm32/alloc-id _string-break-if-float</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32
25421 0x11/imm32/alloc-id _string-loop-if-float</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32
25422 0x11/imm32/alloc-id _string-break-if-float>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32
25423 0x11/imm32/alloc-id _string-loop-if-float>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32
25424 0x11/imm32/alloc-id _string-break-if-float<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32
25425 0x11/imm32/alloc-id _string-loop-if-float<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32
25426 0x11/imm32/alloc-id _string-break-if-float>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32
25427 0x11/imm32/alloc-id _string-loop-if-float>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32
25428
25429 == code
25430
25431 emit-unconditional-jump-to-depth:
25432
25433 55/push-ebp
25434 89/<- %ebp 4/r32/esp
25435
25436 50/push-eax
25437 51/push-ecx
25438 52/push-edx
25439 53/push-ebx
25440 56/push-esi
25441
25442 8b/-> *(ebp+0xc) 1/r32/ecx
25443
25444 8b/-> *ecx 0/r32/eax
25445
25446 8d/copy-address *(ecx+eax-4) 6/r32/esi
25447
25448 8d/copy-address *(ecx+8) 1/r32/ecx
25449
25450 8b/-> *(ebp+0x10) 2/r32/edx
25451 {
25452 $emit-unconditional-jump-to-depth:loop:
25453
25454 39/compare %esi 1/r32/ecx
25455 0f 82/jump-if-addr< break/disp32
25456
25457 (lookup *esi *(esi+4))
25458 89/<- %ebx 0/r32/eax
25459
25460 39/compare *(ebx+0x10) 2/r32/edx
25461 0f 8c/jump-if-< break/disp32
25462 {
25463 $emit-unconditional-jump-to-depth:check:
25464
25465 39/compare *(ebx+0x10) 2/r32/edx
25466 0f 85/jump-if-!= break/disp32
25467 $emit-unconditional-jump-to-depth:depth-found:
25468
25469 (size-of %ebx)
25470 3d/compare-eax-and 0/imm32
25471 0f 85/jump-if-!= break/disp32
25472 $emit-unconditional-jump-to-depth:label-found:
25473
25474 (emit-indent *(ebp+8) *Curr-block-depth)
25475 (write-buffered *(ebp+8) "e9/jump ")
25476 (lookup *ebx *(ebx+4))
25477 (write-buffered *(ebp+8) %eax)
25478 (write-buffered *(ebp+8) ":")
25479 (write-buffered *(ebp+8) *(ebp+0x14))
25480 (write-buffered *(ebp+8) "/disp32\n")
25481 eb/jump $emit-unconditional-jump-to-depth:end/disp8
25482 }
25483
25484 81 5/subop/subtract %esi 0xc/imm32
25485 e9/jump loop/disp32
25486 }
25487
25488 $emit-unconditional-jump-to-depth:end:
25489
25490 5e/pop-to-esi
25491 5b/pop-to-ebx
25492 5a/pop-to-edx
25493 59/pop-to-ecx
25494 58/pop-to-eax
25495
25496 89/<- %esp 5/r32/ebp
25497 5d/pop-to-ebp
25498 c3/return
25499
25500
25501
25502 emit-cleanup-code-until-depth:
25503
25504 55/push-ebp
25505 89/<- %ebp 4/r32/esp
25506
25507 50/push-eax
25508 51/push-ecx
25509 52/push-edx
25510 53/push-ebx
25511 56/push-esi
25512
25513
25514
25515 8b/-> *(ebp+0xc) 1/r32/ecx
25516
25517 8b/-> *ecx 6/r32/esi
25518
25519 8d/copy-address *(ecx+esi-4) 6/r32/esi
25520
25521 81 0/subop/add %ecx 8/imm32
25522
25523 8b/-> *(ebp+0x10) 2/r32/edx
25524 {
25525 $emit-cleanup-code-until-depth:loop:
25526
25527 39/compare %esi 1/r32/ecx
25528 0f 82/jump-if-addr< break/disp32
25529
25530 (lookup *esi *(esi+4))
25531 89/<- %ebx 0/r32/eax
25532
25533
25534
25535
25536
25537
25538 39/compare *(ebx+0x10) 2/r32/edx
25539 0f 8c/jump-if-< break/disp32
25540
25541 81 7/subop/compare *(ebx+0x18) 0/imm32
25542 {
25543 0f 84/jump-if-= break/disp32
25544 {
25545 $emit-cleanup-code-until-depth:check-for-previous-spill:
25546 8b/-> *(esi+8) 0/r32/eax
25547 3d/compare-eax-and 0/imm32/false
25548 74/jump-if-= break/disp8
25549 $emit-cleanup-code-until-depth:reclaim-var-in-register:
25550 (lookup *(ebx+0x18) *(ebx+0x1c))
25551 (emit-pop-register *(ebp+8) %eax)
25552 }
25553 eb/jump $emit-cleanup-code-until-depth:continue/disp8
25554 }
25555
25556 {
25557 75/jump-if-!= break/disp8
25558 $emit-cleanup-code-until-depth:var-on-stack:
25559 (size-of %ebx)
25560
25561 3d/compare-eax-and 0/imm32
25562 74/jump-if-= break/disp8
25563 $emit-cleanup-code-until-depth:reclaim-var-on-stack:
25564 (emit-indent *(ebp+8) *Curr-block-depth)
25565 (write-buffered *(ebp+8) "81 0/subop/add %esp ")
25566 (write-int32-hex-buffered *(ebp+8) %eax)
25567 (write-buffered *(ebp+8) "/imm32\n")
25568 }
25569 $emit-cleanup-code-until-depth:continue:
25570
25571 81 5/subop/subtract %esi 0xc/imm32
25572 e9/jump loop/disp32
25573 }
25574 $emit-cleanup-code-until-depth:end:
25575
25576 5e/pop-to-esi
25577 5b/pop-to-ebx
25578 5a/pop-to-edx
25579 59/pop-to-ecx
25580 58/pop-to-eax
25581
25582 89/<- %esp 5/r32/ebp
25583 5d/pop-to-ebp
25584 c3/return
25585
25586
25587
25588 emit-cleanup-code-for-non-outputs:
25589
25590 55/push-ebp
25591 89/<- %ebp 4/r32/esp
25592
25593 50/push-eax
25594 51/push-ecx
25595 52/push-edx
25596 53/push-ebx
25597 56/push-esi
25598 57/push-edi
25599
25600 8b/-> *(ebp+0xc) 1/r32/ecx
25601
25602 8b/-> *ecx 6/r32/esi
25603
25604 8d/copy-address *(ecx+esi-4) 6/r32/esi
25605
25606 81 0/subop/add %ecx 8/imm32
25607 {
25608 $emit-cleanup-code-for-non-outputs:loop:
25609
25610 39/compare %esi 1/r32/ecx
25611 0f 82/jump-if-addr< break/disp32
25612
25613 (lookup *esi *(esi+4))
25614 89/<- %ebx 0/r32/eax
25615
25616 81 7/subop/compare *(ebx+0x18) 0/imm32
25617 {
25618 0f 84/jump-if-= break/disp32
25619 {
25620 $emit-cleanup-code-for-non-outputs:check-for-previous-spill:
25621 8b/-> *(esi+8) 0/r32/eax
25622 3d/compare-eax-and 0/imm32/false
25623 0f 84/jump-if-= break/disp32
25624 $emit-cleanup-code-for-non-outputs:reclaim-var-in-register:
25625
25626 (lookup *(ebx+0x18) *(ebx+0x1c))
25627 89/<- %edi 0/r32/eax
25628
25629 (reg-in-function-outputs? *(ebp+0x10) %edi)
25630 3d/compare-eax-and 0/imm32/false
25631 {
25632 75/jump-if-!= break/disp8
25633 (emit-pop-register *(ebp+8) %edi)
25634 eb/jump $emit-cleanup-code-for-non-outputs:reclaim-var-in-register-done/disp8
25635 }
25636
25637 (emit-indent *(ebp+8) *Curr-block-depth)
25638 (write-buffered *(ebp+8) "81 0/subop/add %esp 4/imm32\n")
25639 }
25640 $emit-cleanup-code-for-non-outputs:reclaim-var-in-register-done:
25641 eb/jump $emit-cleanup-code-for-non-outputs:continue/disp8
25642 }
25643
25644 {
25645 75/jump-if-!= break/disp8
25646 $emit-cleanup-code-for-non-outputs:var-on-stack:
25647 (size-of %ebx)
25648
25649 3d/compare-eax-and 0/imm32
25650 74/jump-if-= break/disp8
25651 $emit-cleanup-code-for-non-outputs:reclaim-var-on-stack:
25652 (emit-indent *(ebp+8) *Curr-block-depth)
25653 (write-buffered *(ebp+8) "81 0/subop/add %esp ")
25654 (write-int32-hex-buffered *(ebp+8) %eax)
25655 (write-buffered *(ebp+8) "/imm32\n")
25656 }
25657 $emit-cleanup-code-for-non-outputs:continue:
25658
25659 81 5/subop/subtract %esi 0xc/imm32
25660 e9/jump loop/disp32
25661 }
25662 $emit-cleanup-code-for-non-outputs:end:
25663
25664 5f/pop-to-edi
25665 5e/pop-to-esi
25666 5b/pop-to-ebx
25667 5a/pop-to-edx
25668 59/pop-to-ecx
25669 58/pop-to-eax
25670
25671 89/<- %esp 5/r32/ebp
25672 5d/pop-to-ebp
25673 c3/return
25674
25675 emit-push-register:
25676
25677 55/push-ebp
25678 89/<- %ebp 4/r32/esp
25679
25680 8b/-> *(ebp+0xc) 0/r32/eax
25681
25682 8a/copy-byte *(eax+4) 0/r32/AL
25683 81 4/subop/and %eax 0xff/imm32
25684
25685 {
25686 3d/compare-eax-and 0x78/imm32/x
25687 0f 85/jump-if-!= break/disp32
25688
25689 (emit-indent *(ebp+8) *Curr-block-depth)
25690 (write-buffered *(ebp+8) "81 5/subop/subtract %esp 4/imm32\n")
25691 (emit-indent *(ebp+8) *Curr-block-depth)
25692 (write-buffered *(ebp+8) "f3 0f 11/<- *esp ")
25693
25694 8b/-> *(ebp+0xc) 0/r32/eax
25695 8a/copy-byte *(eax+7) 0/r32/AL
25696 81 4/subop/and %eax 0xff/imm32
25697 (write-byte-buffered *(ebp+8) %eax)
25698 (write-buffered *(ebp+8) "/x32\n")
25699 e9/jump $emit-push-register:end/disp32
25700 }
25701
25702 (emit-indent *(ebp+8) *Curr-block-depth)
25703 (write-buffered *(ebp+8) "ff 6/subop/push %")
25704 (write-buffered *(ebp+8) *(ebp+0xc))
25705 (write-buffered *(ebp+8) Newline)
25706 $emit-push-register:end:
25707
25708 89/<- %esp 5/r32/ebp
25709 5d/pop-to-ebp
25710 c3/return
25711
25712 emit-pop-register:
25713
25714 55/push-ebp
25715 89/<- %ebp 4/r32/esp
25716
25717 50/push-eax
25718
25719 8b/-> *(ebp+0xc) 0/r32/eax
25720
25721 8a/copy-byte *(eax+4) 0/r32/AL
25722 81 4/subop/and %eax 0xff/imm32
25723
25724 {
25725 3d/compare-eax-and 0x78/imm32/x
25726 0f 85/jump-if-!= break/disp32
25727
25728 (emit-indent *(ebp+8) *Curr-block-depth)
25729 (write-buffered *(ebp+8) "f3 0f 10/-> *esp ")
25730
25731 8b/-> *(ebp+0xc) 0/r32/eax
25732 8a/copy-byte *(eax+7) 0/r32/AL
25733 81 4/subop/and %eax 0xff/imm32
25734 (write-byte-buffered *(ebp+8) %eax)
25735 (write-buffered *(ebp+8) "/x32\n")
25736 (emit-indent *(ebp+8) *Curr-block-depth)
25737 (write-buffered *(ebp+8) "81 0/subop/add %esp 4/imm32\n")
25738 e9/jump $emit-pop-register:end/disp32
25739 }
25740
25741 (emit-indent *(ebp+8) *Curr-block-depth)
25742 (write-buffered *(ebp+8) "8f 0/subop/pop %")
25743 (write-buffered *(ebp+8) *(ebp+0xc))
25744 (write-buffered *(ebp+8) Newline)
25745 $emit-pop-register:end:
25746
25747 58/pop-to-eax
25748
25749 89/<- %esp 5/r32/ebp
25750 5d/pop-to-ebp
25751 c3/return
25752
25753
25754
25755 emit-cleanup-code-until-target:
25756
25757 55/push-ebp
25758 89/<- %ebp 4/r32/esp
25759
25760 50/push-eax
25761 51/push-ecx
25762 52/push-edx
25763 53/push-ebx
25764
25765 8b/-> *(ebp+0xc) 1/r32/ecx
25766
25767 8b/-> *ecx 0/r32/eax
25768
25769 8d/copy-address *(ecx+eax-4) 2/r32/edx
25770
25771 81 0/subop/add %ecx 8/imm32
25772 {
25773 $emit-cleanup-code-until-target:loop:
25774
25775 39/compare %edx 1/r32/ecx
25776 0f 82/jump-if-addr< break/disp32
25777
25778 (lookup *edx *(edx+4))
25779 89/<- %ebx 0/r32/eax
25780
25781 (lookup *ebx *(ebx+4))
25782 (string-equal? %eax *(ebp+0x10))
25783 3d/compare-eax-and 0/imm32/false
25784 0f 85/jump-if-!= break/disp32
25785
25786 81 7/subop/compare *(ebx+0x18) 0/imm32
25787 {
25788 0f 84/jump-if-= break/disp32
25789 {
25790 $emit-cleanup-code-until-target:check-for-previous-spill:
25791 8b/-> *(edx+8) 0/r32/eax
25792 3d/compare-eax-and 0/imm32/false
25793 74/jump-if-= break/disp8
25794 $emit-cleanup-code-until-target:reclaim-var-in-register:
25795 (lookup *(ebx+0x18) *(ebx+0x1c))
25796 (emit-pop-register *(ebp+8) %eax)
25797 }
25798 eb/jump $emit-cleanup-code-until-target:continue/disp8
25799 }
25800
25801 {
25802 75/jump-if-!= break/disp8
25803 $emit-cleanup-code-until-target:reclaim-var-on-stack:
25804 (size-of %ebx)
25805
25806 3d/compare-eax-and 0/imm32
25807 74/jump-if-= break/disp8
25808
25809 (emit-indent *(ebp+8) *Curr-block-depth)
25810 (write-buffered *(ebp+8) "81 0/subop/add %esp ")
25811 (write-int32-hex-buffered *(ebp+8) %eax)
25812 (write-buffered *(ebp+8) "/imm32\n")
25813 }
25814 $emit-cleanup-code-until-target:continue:
25815
25816 81 5/subop/subtract %edx 0xc/imm32
25817 e9/jump loop/disp32
25818 }
25819 $emit-cleanup-code-until-target:end:
25820
25821 5b/pop-to-ebx
25822 5a/pop-to-edx
25823 59/pop-to-ecx
25824 58/pop-to-eax
25825
25826 89/<- %esp 5/r32/ebp
25827 5d/pop-to-ebp
25828 c3/return
25829
25830
25831
25832 clean-up-stack-offset-state:
25833
25834 55/push-ebp
25835 89/<- %ebp 4/r32/esp
25836
25837 50/push-eax
25838 51/push-ecx
25839 52/push-edx
25840 53/push-ebx
25841 56/push-esi
25842
25843 8b/-> *(ebp+8) 1/r32/ecx
25844
25845 8b/-> *ecx 6/r32/esi
25846
25847 8d/copy-address *(ecx+esi-4) 6/r32/esi
25848
25849 81 0/subop/add %ecx 8/imm32
25850
25851 8b/-> *(ebp+0xc) 2/r32/edx
25852 {
25853 $clean-up-stack-offset-state:loop:
25854
25855 39/compare %esi 1/r32/ecx
25856 0f 82/jump-if-addr< break/disp32
25857
25858 (lookup *esi *(esi+4))
25859 89/<- %ebx 0/r32/eax
25860
25861 39/compare *(ebx+0x10) 2/r32/edx
25862 0f 8c/jump-if-< break/disp32
25863
25864 81 7/subop/compare *(ebx+0x18) 0/imm32
25865 {
25866 0f 84/jump-if-= break/disp32
25867 {
25868 $clean-up-stack-offset-state:check-for-previous-spill:
25869 8b/-> *(esi+8) 0/r32/eax
25870 3d/compare-eax-and 0/imm32/false
25871 74/jump-if-= break/disp8
25872 $clean-up-stack-offset-state:reclaim-var-in-register:
25873 81 0/subop/add *Curr-local-stack-offset 4/imm32
25874 }
25875 eb/jump $clean-up-stack-offset-state:continue/disp8
25876 }
25877
25878 {
25879 75/jump-if-!= break/disp8
25880 $clean-up-stack-offset-state:var-on-stack:
25881 (size-of %ebx)
25882 01/add-to *Curr-local-stack-offset 0/r32/eax
25883 }
25884 $clean-up-stack-offset-state:continue:
25885
25886 81 5/subop/subtract %esi 0xc/imm32
25887 e9/jump loop/disp32
25888 }
25889 $clean-up-stack-offset-state:end:
25890
25891 5e/pop-to-esi
25892 5b/pop-to-ebx
25893 5a/pop-to-edx
25894 59/pop-to-ecx
25895 58/pop-to-eax
25896
25897 89/<- %esp 5/r32/ebp
25898 5d/pop-to-ebp
25899 c3/return
25900
25901
25902
25903
25904 not-yet-spilled-this-block?:
25905
25906 55/push-ebp
25907 89/<- %ebp 4/r32/esp
25908
25909 51/push-ecx
25910 52/push-edx
25911 53/push-ebx
25912 56/push-esi
25913 57/push-edi
25914
25915 8b/-> *(ebp+0xc) 1/r32/ecx
25916
25917 8b/-> *ecx 0/r32/eax
25918
25919 8d/copy-address *(ecx+eax-4) 2/r32/edx
25920
25921 8d/copy-address *(ecx+8) 1/r32/ecx
25922
25923 8b/-> *(ebp+8) 3/r32/ebx
25924 8b/-> *(ebx+0x10) 3/r32/ebx
25925
25926 8b/-> *(ebp+8) 6/r32/esi
25927 (lookup *(esi+0x18) *(esi+0x1c))
25928 89/<- %esi 0/r32/eax
25929 {
25930 $not-yet-spilled-this-block?:loop:
25931
25932 39/compare %edx 1/r32/ecx
25933 0f 82/jump-if-addr< break/disp32
25934
25935 (lookup *edx *(edx+4))
25936 89/<- %edi 0/r32/eax
25937
25938 39/compare *(edi+0x10) 3/r32/ebx
25939 0f 8c/jump-if-< break/disp32
25940
25941 (lookup *(edi+0x18) *(edi+0x1c))
25942 89/<- %edi 0/r32/eax
25943
25944 {
25945 $not-yet-spilled-this-block?:check-reg:
25946 81 7/subop/compare %edi 0/imm32
25947 0f 84/jump-if-= break/disp32
25948
25949 (string-equal? %esi %edi)
25950 3d/compare-eax-and 0/imm32/false
25951 74/jump-if-= break/disp8
25952 $not-yet-spilled-this-block?:return-false:
25953 b8/copy-to-eax 0/imm32/false
25954 eb/jump $not-yet-spilled-this-block?:end/disp8
25955 }
25956 $not-yet-spilled-this-block?:continue:
25957
25958 81 5/subop/subtract %edx 0xc/imm32
25959 e9/jump loop/disp32
25960 }
25961 $not-yet-spilled-this-block?:return-true:
25962
25963 b8/copy-to-eax 1/imm32/true
25964 $not-yet-spilled-this-block?:end:
25965
25966 5f/pop-to-edi
25967 5e/pop-to-esi
25968 5b/pop-to-ebx
25969 5a/pop-to-edx
25970 59/pop-to-ecx
25971
25972 89/<- %esp 5/r32/ebp
25973 5d/pop-to-ebp
25974 c3/return
25975
25976
25977 will-not-write-some-register?:
25978
25979 55/push-ebp
25980 89/<- %ebp 4/r32/esp
25981
25982 8b/-> *(ebp+8) 0/r32/eax
25983
25984 (lookup *(eax+0x18) *(eax+0x1c))
25985
25986 (find-register *(ebp+0x10) %eax)
25987
25988 {
25989 3d/compare-eax-and 0/imm32
25990 75/jump-if-!= break/disp8
25991 b8/copy-to-eax 1/imm32/true
25992 eb/jump $will-not-write-some-register?:end/disp8
25993 }
25994
25995 (assigns-in-stmts? *(ebp+0xc) %eax)
25996 3d/compare-eax-and 0/imm32/false
25997
25998 0f 94/set-if-= %al
25999 $will-not-write-some-register?:end:
26000
26001 89/<- %esp 5/r32/ebp
26002 5d/pop-to-ebp
26003 c3/return
26004
26005
26006
26007 find-register:
26008
26009 55/push-ebp
26010 89/<- %ebp 4/r32/esp
26011
26012 51/push-ecx
26013
26014 8b/-> *(ebp+8) 1/r32/ecx
26015 (lookup *(ecx+0x10) *(ecx+0x14))
26016 89/<- %ecx 0/r32/eax
26017 {
26018 $find-register:loop:
26019
26020 81 7/subop/compare %ecx 0/imm32
26021 74/jump-if-= break/disp8
26022
26023 (lookup *ecx *(ecx+4))
26024 (lookup *(eax+0x18) *(eax+0x1c))
26025
26026 $find-register:compare:
26027 (string-equal? *(ebp+0xc) %eax)
26028 {
26029 3d/compare-eax-and 0/imm32/false
26030 74/jump-if-= break/disp8
26031 $find-register:found:
26032 (lookup *ecx *(ecx+4))
26033 eb/jump $find-register:end/disp8
26034 }
26035
26036 (lookup *(ecx+8) *(ecx+0xc))
26037 89/<- %ecx 0/r32/eax
26038
26039 eb/jump loop/disp8
26040 }
26041 $find-register:end:
26042
26043 59/pop-to-ecx
26044
26045 89/<- %esp 5/r32/ebp
26046 5d/pop-to-ebp
26047 c3/return
26048
26049 assigns-in-stmts?:
26050
26051 55/push-ebp
26052 89/<- %ebp 4/r32/esp
26053
26054 51/push-ecx
26055
26056 8b/-> *(ebp+8) 1/r32/ecx
26057 {
26058
26059 81 7/subop/compare %ecx 0/imm32
26060 74/jump-if-= break/disp8
26061
26062 (lookup *ecx *(ecx+4))
26063 (assigns-in-stmt? %eax *(ebp+0xc))
26064 3d/compare-eax-and 0/imm32/false
26065 75/jump-if-!= break/disp8
26066
26067 (lookup *(ecx+8) *(ecx+0xc))
26068 89/<- %ecx 0/r32/eax
26069
26070 eb/jump loop/disp8
26071 }
26072 $assigns-in-stmts?:end:
26073
26074 59/pop-to-ecx
26075
26076 89/<- %esp 5/r32/ebp
26077 5d/pop-to-ebp
26078 c3/return
26079
26080 assigns-in-stmt?:
26081
26082 55/push-ebp
26083 89/<- %ebp 4/r32/esp
26084
26085 51/push-ecx
26086
26087 8b/-> *(ebp+8) 1/r32/ecx
26088
26089 {
26090 81 7/subop/compare *ecx 1/imm32/stmt1
26091 75/jump-if-!= break/disp8
26092 (lookup *(ecx+0x14) *(ecx+0x18))
26093 (assigns-in-stmt-vars? %eax *(ebp+0xc))
26094 eb/jump $assigns-in-stmt?:end/disp8
26095 }
26096
26097 {
26098 81 7/subop/compare *ecx 0/imm32/block
26099 75/jump-if-!= break/disp8
26100 (lookup *(ecx+4) *(ecx+8))
26101 (assigns-in-stmts? %eax *(ebp+0xc))
26102 eb/jump $assigns-in-stmt?:end/disp8
26103 }
26104
26105 b8/copy 0/imm32/false
26106 $assigns-in-stmt?:end:
26107
26108 59/pop-to-ecx
26109
26110 89/<- %esp 5/r32/ebp
26111 5d/pop-to-ebp
26112 c3/return
26113
26114 assigns-in-stmt-vars?:
26115
26116 55/push-ebp
26117 89/<- %ebp 4/r32/esp
26118
26119 51/push-ecx
26120
26121 8b/-> *(ebp+8) 1/r32/ecx
26122 {
26123
26124 81 7/subop/compare %ecx 0/imm32
26125 74/jump-if-= break/disp8
26126
26127 (lookup *ecx *(ecx+4))
26128
26129 {
26130 39/compare *(ebp+0xc) 0/r32/eax
26131 75/jump-if-!= break/disp8
26132 81 7/subop/compare *(ecx+0x10) 0/imm32/false
26133 75/jump-if-!= break/disp8
26134 b8/copy-to-eax 1/imm32/true
26135 eb/jump $assigns-in-stmt-vars?:end/disp8
26136 }
26137
26138 (lookup *(ecx+8) *(ecx+0xc))
26139 89/<- %ecx 0/r32/eax
26140
26141 eb/jump loop/disp8
26142 }
26143 $assigns-in-stmt-vars?:end:
26144
26145 59/pop-to-ecx
26146
26147 89/<- %esp 5/r32/ebp
26148 5d/pop-to-ebp
26149 c3/return
26150
26151
26152
26153
26154
26155 same-register-spilled-before?:
26156
26157 55/push-ebp
26158 89/<- %ebp 4/r32/esp
26159
26160 51/push-ecx
26161 52/push-edx
26162 53/push-ebx
26163 56/push-esi
26164 57/push-edi
26165
26166 8b/-> *(ebp+8) 1/r32/ecx
26167
26168 (lookup *(ecx+0x18) *(ecx+0x1c))
26169 89/<- %edx 0/r32/eax
26170
26171 8b/-> *(ecx+0x10) 3/r32/ebx
26172
26173 8b/-> *(ebp+0xc) 1/r32/ecx
26174 81 0/subop/add %ecx 8/imm32
26175
26176
26177
26178 8b/-> *(ebp+0x10) 6/r32/esi
26179
26180 81 5/subop/subtract %esi 8/imm32
26181 {
26182 $same-register-spilled-before?:loop:
26183
26184 39/compare %esi 1/r32/ecx
26185 0f 82/jump-if-addr< break/disp32
26186
26187 (lookup *esi *(esi+4))
26188
26189 39/compare *(eax+0x10) 3/r32/ebx
26190 0f 8c/jump-if-< break/disp32
26191
26192 81 7/subop/compare *(eax+0x18) 0/imm32
26193 74/jump-if-= $same-register-spilled-before?:continue/disp8
26194
26195 (lookup *(eax+0x18) *(eax+0x1c))
26196 (string-equal? %eax %edx)
26197 3d/compare-eax-and 0/imm32/false
26198 b8/copy-to-eax 1/imm32/true
26199 75/jump-if-!= $same-register-spilled-before?:end/disp8
26200 $same-register-spilled-before?:continue:
26201
26202 81 5/subop/subtract %esi 8/imm32
26203 e9/jump loop/disp32
26204 }
26205 $same-register-spilled-before?:false:
26206 b8/copy-to-eax 0/imm32/false
26207 $same-register-spilled-before?:end:
26208
26209 5f/pop-to-edi
26210 5e/pop-to-esi
26211 5b/pop-to-ebx
26212 5a/pop-to-edx
26213 59/pop-to-ecx
26214
26215 89/<- %esp 5/r32/ebp
26216 5d/pop-to-ebp
26217 c3/return
26218
26219
26220 clean-up-blocks:
26221
26222 55/push-ebp
26223 89/<- %ebp 4/r32/esp
26224
26225 50/push-eax
26226 51/push-ecx
26227 56/push-esi
26228
26229 8b/-> *(ebp+8) 6/r32/esi
26230
26231 8b/-> *(ebp+0xc) 1/r32/ecx
26232 {
26233 $clean-up-blocks:reclaim-loop:
26234
26235 8b/-> *esi 0/r32/eax
26236 3d/compare-eax-and 0/imm32
26237 0f 8e/jump-if-<= break/disp32
26238
26239 (lookup *(esi+eax-4) *(esi+eax))
26240
26241 39/compare *(eax+0x10) 1/r32/ecx
26242 0f 8c/jump-if-< break/disp32
26243 (pop %esi)
26244 (pop %esi)
26245 (pop %esi)
26246 e9/jump loop/disp32
26247 }
26248 $clean-up-blocks:end:
26249
26250 5e/pop-to-esi
26251 59/pop-to-ecx
26252 58/pop-to-eax
26253
26254 89/<- %esp 5/r32/ebp
26255 5d/pop-to-ebp
26256 c3/return
26257
26258 reg-in-function-outputs?:
26259
26260 55/push-ebp
26261 89/<- %ebp 4/r32/esp
26262
26263 51/push-ecx
26264
26265 8b/-> *(ebp+8) 0/r32/eax
26266 (lookup *(eax+0x10) *(eax+0x14))
26267 89/<- %ecx 0/r32/eax
26268
26269 {
26270 81 7/subop/compare %ecx 0/imm32
26271 74/jump-if-= break/disp8
26272
26273 (lookup *ecx *(ecx+4))
26274
26275 (lookup *(eax+0x18) *(eax+0x1c))
26276
26277 (string-equal? %eax *(ebp+0xc))
26278 3d/compare-eax-and 0/imm32/false
26279 75/jump-if-!= $reg-in-function-outputs?:end/disp8
26280
26281 (lookup *(ecx+8) *(ecx+0xc))
26282 89/<- %ecx 0/r32/eax
26283
26284 eb/jump loop/disp8
26285 }
26286
26287 b8/copy-to-eax 0/imm32
26288 $reg-in-function-outputs?:end:
26289
26290 59/pop-to-ecx
26291
26292 89/<- %esp 5/r32/ebp
26293 5d/pop-to-ebp
26294 c3/return
26295
26296 emit-subx-var-def:
26297
26298 55/push-ebp
26299 89/<- %ebp 4/r32/esp
26300
26301 50/push-eax
26302 51/push-ecx
26303 52/push-edx
26304
26305 8b/-> *(ebp+0xc) 0/r32/eax
26306
26307 (lookup *(eax+4) *(eax+8))
26308 89/<- %ecx 0/r32/eax
26309
26310 8b/-> *Curr-block-depth 0/r32/eax
26311 89/<- *(ecx+0x10) 0/r32/eax
26312
26313 (size-of %ecx)
26314 89/<- %edx 0/r32/eax
26315
26316 29/subtract-from *Curr-local-stack-offset 2/r32/edx
26317
26318 8b/-> *Curr-local-stack-offset 0/r32/eax
26319 89/<- *(ecx+0x14) 0/r32/eax
26320
26321 {
26322 (lookup *(ecx+8) *(ecx+0xc))
26323 (is-mu-array? %eax)
26324 3d/compare-eax-and 0/imm32/false
26325 0f 84/jump-if-= break/disp32
26326
26327 81 5/subop/subtract %edx 4/imm32
26328
26329 (emit-array-data-initialization *(ebp+8) %edx)
26330 e9/jump $emit-subx-var-def:end/disp32
26331 }
26332
26333
26334 {
26335 (lookup *(ecx+8) *(ecx+0xc))
26336 (is-mu-stream? %eax)
26337 3d/compare-eax-and 0/imm32/false
26338 0f 84/jump-if-= break/disp32
26339
26340 81 5/subop/subtract %edx 0xc/imm32
26341 (emit-array-data-initialization *(ebp+8) %edx)
26342
26343 (emit-indent *(ebp+8) *Curr-block-depth)
26344 (write-buffered *(ebp+8) "68/push 0/imm32\n")
26345 (emit-indent *(ebp+8) *Curr-block-depth)
26346 (write-buffered *(ebp+8) "68/push 0/imm32\n")
26347
26348 eb/jump $emit-subx-var-def:end/disp8
26349 }
26350
26351 {
26352 81 7/subop/compare %edx 0/imm32
26353 7e/jump-if-<= break/disp8
26354 (emit-indent *(ebp+8) *Curr-block-depth)
26355 (write-buffered *(ebp+8) "68/push 0/imm32\n")
26356
26357 81 5/subop/subtract %edx 4/imm32
26358
26359 eb/jump loop/disp8
26360 }
26361 $emit-subx-var-def:end:
26362
26363 5a/pop-to-edx
26364 59/pop-to-ecx
26365 58/pop-to-eax
26366
26367 89/<- %esp 5/r32/ebp
26368 5d/pop-to-ebp
26369 c3/return
26370
26371 emit-array-data-initialization:
26372
26373 55/push-ebp
26374 89/<- %ebp 4/r32/esp
26375
26376 (emit-indent *(ebp+8) *Curr-block-depth)
26377 (write-buffered *(ebp+8) "(push-n-zero-bytes ")
26378 (write-int32-hex-buffered *(ebp+8) *(ebp+0xc))
26379 (write-buffered *(ebp+8) ")\n")
26380 (emit-indent *(ebp+8) *Curr-block-depth)
26381 (write-buffered *(ebp+8) "68/push ")
26382 (write-int32-hex-buffered *(ebp+8) *(ebp+0xc))
26383 (write-buffered *(ebp+8) "/imm32\n")
26384 $emit-array-data-initialization:end:
26385
26386 89/<- %esp 5/r32/ebp
26387 5d/pop-to-ebp
26388 c3/return
26389
26390 emit-subx-stmt:
26391
26392 55/push-ebp
26393 89/<- %ebp 4/r32/esp
26394
26395 50/push-eax
26396 51/push-ecx
26397
26398
26399 8b/-> *(ebp+0xc) 1/r32/ecx
26400 (lookup *(ecx+4) *(ecx+8))
26401 89/<- %ecx 0/r32/eax
26402
26403 {
26404
26405 (string-equal? %ecx "length")
26406 3d/compare-eax-and 0/imm32
26407 0f 84/jump-if-= break/disp32
26408 (translate-mu-length-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x18) *(ebp+0x1c))
26409 e9/jump $emit-subx-stmt:end/disp32
26410 }
26411
26412 {
26413
26414 (string-equal? %ecx "index")
26415 3d/compare-eax-and 0/imm32
26416 0f 84/jump-if-= break/disp32
26417 (translate-mu-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c))
26418 e9/jump $emit-subx-stmt:end/disp32
26419 }
26420
26421 {
26422
26423 (string-equal? %ecx "compute-offset")
26424 3d/compare-eax-and 0/imm32
26425 0f 84/jump-if-= break/disp32
26426 (translate-mu-compute-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x18) *(ebp+0x1c))
26427 e9/jump $emit-subx-stmt:end/disp32
26428 }
26429
26430 {
26431
26432 (string-equal? %ecx "get")
26433 3d/compare-eax-and 0/imm32
26434 0f 84/jump-if-= break/disp32
26435 (translate-mu-get-stmt *(ebp+8) *(ebp+0xc))
26436 e9/jump $emit-subx-stmt:end/disp32
26437 }
26438
26439 {
26440
26441 (string-equal? %ecx "allocate")
26442 3d/compare-eax-and 0/imm32
26443 0f 84/jump-if-= break/disp32
26444 (translate-mu-allocate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x18) *(ebp+0x1c))
26445 e9/jump $emit-subx-stmt:end/disp32
26446 }
26447
26448 {
26449
26450 (string-equal? %ecx "copy-object")
26451 3d/compare-eax-and 0/imm32
26452 0f 84/jump-if-= break/disp32
26453 (translate-mu-copy-object-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x18) *(ebp+0x1c))
26454 e9/jump $emit-subx-stmt:end/disp32
26455 }
26456
26457 {
26458
26459 (string-equal? %ecx "clear-object")
26460 3d/compare-eax-and 0/imm32
26461 0f 84/jump-if-= break/disp32
26462 (translate-mu-clear-object-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x18) *(ebp+0x1c))
26463 e9/jump $emit-subx-stmt:end/disp32
26464 }
26465
26466 {
26467
26468 (string-equal? %ecx "populate")
26469 3d/compare-eax-and 0/imm32
26470 0f 84/jump-if-= break/disp32
26471 (translate-mu-populate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x18) *(ebp+0x1c))
26472 e9/jump $emit-subx-stmt:end/disp32
26473 }
26474
26475 {
26476
26477 (string-equal? %ecx "populate-stream")
26478 3d/compare-eax-and 0/imm32
26479 0f 84/jump-if-= break/disp32
26480 (translate-mu-populate-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x18) *(ebp+0x1c))
26481 e9/jump $emit-subx-stmt:end/disp32
26482 }
26483
26484 {
26485
26486 (string-equal? %ecx "read-from-stream")
26487 3d/compare-eax-and 0/imm32
26488 0f 84/jump-if-= break/disp32
26489 (translate-mu-read-from-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x18) *(ebp+0x1c))
26490 e9/jump $emit-subx-stmt:end/disp32
26491 }
26492
26493 {
26494
26495 (string-equal? %ecx "write-to-stream")
26496 3d/compare-eax-and 0/imm32
26497 0f 84/jump-if-= break/disp32
26498 (translate-mu-write-to-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x18) *(ebp+0x1c))
26499 e9/jump $emit-subx-stmt:end/disp32
26500 }
26501
26502 {
26503 $emit-subx-stmt:check-for-primitive:
26504
26505 (find-matching-primitive *(ebp+0x10) *(ebp+0xc))
26506 3d/compare-eax-and 0/imm32
26507 74/jump-if-= break/disp8
26508 $emit-subx-stmt:primitive:
26509 (emit-subx-primitive *(ebp+8) *(ebp+0xc) %eax)
26510 e9/jump $emit-subx-stmt:end/disp32
26511 }
26512
26513
26514 $emit-subx-stmt:call:
26515 (emit-call *(ebp+8) *(ebp+0xc))
26516 $emit-subx-stmt:end:
26517
26518 59/pop-to-ecx
26519 58/pop-to-eax
26520
26521 89/<- %esp 5/r32/ebp
26522 5d/pop-to-ebp
26523 c3/return
26524
26525 translate-mu-length-stmt:
26526
26527 55/push-ebp
26528 89/<- %ebp 4/r32/esp
26529
26530 50/push-eax
26531 51/push-ecx
26532 52/push-edx
26533 53/push-ebx
26534 56/push-esi
26535
26536 8b/-> *(ebp+0xc) 6/r32/esi
26537
26538 (lookup *(esi+0xc) *(esi+0x10))
26539 (lookup *eax *(eax+4))
26540 89/<- %ebx 0/r32/eax
26541
26542 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14))
26543 89/<- %ecx 0/r32/eax
26544
26545 (lookup *(esi+0x14) *(esi+0x18))
26546 (lookup *eax *(eax+4))
26547 (lookup *(eax+0x18) *(eax+0x1c))
26548 89/<- %edx 0/r32/eax
26549
26550 {
26551 81 7/subop/compare %ecx 1/imm32
26552 75/jump-if-!= break/disp8
26553 $translate-mu-length-stmt:size-1:
26554 (emit-save-size-to *(ebp+8) %ebx %edx)
26555 e9/jump $translate-mu-length-stmt:end/disp32
26556 }
26557
26558 {
26559 (power-of-2? %ecx *(ebp+0x10) *(ebp+0x14))
26560 3d/compare-eax-and 0/imm32/false
26561 74/jump-if-= break/disp8
26562 81 7/subop/compare %ecx 0xff/imm32
26563 7f/jump-if-> break/disp8
26564 $translate-mu-length-stmt:size-power-of-2:
26565 (emit-save-size-to *(ebp+8) %ebx %edx)
26566 (emit-divide-by-shift-right *(ebp+8) %edx %ecx)
26567 e9/jump $translate-mu-length-stmt:end/disp32
26568 }
26569
26570
26571 {
26572 $translate-mu-length-stmt:complex:
26573 (string-equal? %edx "eax")
26574 3d/compare-eax-and 0/imm32/false
26575 75/break-if-!= break/disp8
26576 (emit-indent *(ebp+8) *Curr-block-depth)
26577 (write-buffered *(ebp+8) "50/push-eax\n")
26578 }
26579 {
26580 (string-equal? %edx "ecx")
26581 3d/compare-eax-and 0/imm32/false
26582 75/break-if-!= break/disp8
26583 (emit-indent *(ebp+8) *Curr-block-depth)
26584 (write-buffered *(ebp+8) "51/push-ecx\n")
26585 }
26586 {
26587 (string-equal? %edx "edx")
26588 3d/compare-eax-and 0/imm32/false
26589 75/break-if-!= break/disp8
26590 (emit-indent *(ebp+8) *Curr-block-depth)
26591 (write-buffered *(ebp+8) "52/push-edx\n")
26592 }
26593
26594 (emit-save-size-to *(ebp+8) %ebx "eax")
26595 (emit-indent *(ebp+8) *Curr-block-depth)
26596 (write-buffered *(ebp+8) "31/xor %edx 2/r32/edx\n")
26597 (emit-indent *(ebp+8) *Curr-block-depth)
26598 (write-buffered *(ebp+8) "b9/copy-to-ecx ")
26599 (write-int32-hex-buffered *(ebp+8) %ecx)
26600 (write-buffered *(ebp+8) "/imm32\n")
26601 (emit-indent *(ebp+8) *Curr-block-depth)
26602 (write-buffered *(ebp+8) "f7 7/subop/idiv-eax-edx-by %ecx\n")
26603 {
26604 (string-equal? %edx "eax")
26605 3d/compare-eax-and 0/imm32/false
26606 75/break-if-!= break/disp8
26607 (emit-indent *(ebp+8) *Curr-block-depth)
26608 (write-buffered *(ebp+8) "89/<- %")
26609 (write-buffered *(ebp+8) %edx)
26610 (write-buffered *(ebp+8) " 0/r32/eax\n")
26611 }
26612
26613 {
26614 (string-equal? %edx "edx")
26615 3d/compare-eax-and 0/imm32/false
26616 75/break-if-!= break/disp8
26617 (emit-indent *(ebp+8) *Curr-block-depth)
26618 (write-buffered *(ebp+8) "5a/pop-to-edx\n")
26619 }
26620 {
26621 (string-equal? %edx "ecx")
26622 3d/compare-eax-and 0/imm32/false
26623 75/break-if-!= break/disp8
26624 (emit-indent *(ebp+8) *Curr-block-depth)
26625 (write-buffered *(ebp+8) "59/pop-to-ecx\n")
26626 }
26627 {
26628 (string-equal? %edx "eax")
26629 3d/compare-eax-and 0/imm32/false
26630 75/break-if-!= break/disp8
26631 (emit-indent *(ebp+8) *Curr-block-depth)
26632 (write-buffered *(ebp+8) "58/pop-to-eax\n")
26633 }
26634 $translate-mu-length-stmt:end:
26635
26636 5e/pop-to-esi
26637 5b/pop-to-ebx
26638 5a/pop-to-edx
26639 59/pop-to-ecx
26640 58/pop-to-eax
26641
26642 89/<- %esp 5/r32/ebp
26643 5d/pop-to-ebp
26644 c3/return
26645
26646 array-element-size:
26647
26648 55/push-ebp
26649 89/<- %ebp 4/r32/esp
26650
26651 (array-element-type-id *(ebp+8) *(ebp+0xc) *(ebp+0x10))
26652 (size-of-type-id-as-array-element %eax)
26653 $array-element-size:end:
26654
26655 89/<- %esp 5/r32/ebp
26656 5d/pop-to-ebp
26657 c3/return
26658
26659 array-element-type-id:
26660
26661
26662 55/push-ebp
26663 89/<- %ebp 4/r32/esp
26664
26665 8b/-> *(ebp+8) 0/r32/eax
26666
26667 (lookup *(eax+8) *(eax+0xc))
26668
26669 3d/compare-eax-with 0/imm32
26670 0f 84/jump-if-== $array-element-type-id:error0/disp32
26671
26672 81 7/subop/compare *eax 0/imm32/false
26673 0f 85/jump-if-!= $array-element-type-id:error1/disp32
26674
26675 {
26676 50/push-eax
26677 (lookup *(eax+4) *(eax+8))
26678 (is-simple-mu-type? %eax 2)
26679 3d/compare-eax-with 0/imm32/false
26680 58/pop-to-eax
26681 74/jump-if-= break/disp8
26682 $array-element-type-id:skip-addr:
26683 (lookup *(eax+0xc) *(eax+0x10))
26684 }
26685
26686 3d/compare-eax-with 0/imm32
26687 0f 84/jump-if-= $array-element-type-id:error2/disp32
26688
26689 81 7/subop/compare *eax 0/imm32/false
26690 0f 85/jump-if-!= $array-element-type-id:error2/disp32
26691
26692 {
26693 50/push-eax
26694 (lookup *(eax+4) *(eax+8))
26695 (is-simple-mu-type? %eax 3)
26696 3d/compare-eax-with 0/imm32/false
26697 58/pop-to-eax
26698 $array-element-type-id:no-array:
26699 0f 84/jump-if-= $array-element-type-id:error2/disp32
26700 }
26701 $array-element-type-id:skip-array:
26702
26703 (lookup *(eax+0xc) *(eax+0x10))
26704
26705 3d/compare-eax-with 0/imm32
26706 0f 84/jump-if-= $array-element-type-id:error2/disp32
26707
26708 81 7/subop/compare *eax 0/imm32/false
26709 0f 85/jump-if-!= $array-element-type-id:error2/disp32
26710
26711 (lookup *(eax+4) *(eax+8))
26712
26713
26714 {
26715 81 7/subop/compare *eax 0/imm32/false
26716 75/jump-if-!= break/disp8
26717 (lookup *(eax+4) *(eax+8))
26718 }
26719
26720 8b/-> *(eax+4) 0/r32/eax
26721 $array-element-type-id:end:
26722
26723 89/<- %esp 5/r32/ebp
26724 5d/pop-to-ebp
26725 c3/return
26726
26727 $array-element-type-id:error0:
26728 (write-buffered *(ebp+0xc) "array-element-type-id: var '")
26729 50/push-eax
26730 8b/-> *(ebp+8) 0/r32/eax
26731 (lookup *eax *(eax+4))
26732 (write-buffered *(ebp+0xc) %eax)
26733 58/pop-to-eax
26734 (write-buffered *(ebp+0xc) "' has no type\n")
26735 (flush *(ebp+0xc))
26736 (stop *(ebp+0x10) 1)
26737
26738
26739 $array-element-type-id:error1:
26740 (write-buffered *(ebp+0xc) "array-element-type-id: var '")
26741 50/push-eax
26742 8b/-> *(ebp+8) 0/r32/eax
26743 (lookup *eax *(eax+4))
26744 (write-buffered *(ebp+0xc) %eax)
26745 58/pop-to-eax
26746 (write-buffered *(ebp+0xc) "' has atomic type ")
26747 (write-int32-hex-buffered *(ebp+0xc) *(eax+4))
26748 (write-buffered *(ebp+0xc) Newline)
26749 (flush *(ebp+0xc))
26750 (stop *(ebp+0x10) 1)
26751
26752
26753 $array-element-type-id:error2:
26754 (write-buffered *(ebp+0xc) "array-element-type-id: var '")
26755 50/push-eax
26756 8b/-> *(ebp+8) 0/r32/eax
26757 (lookup *eax *(eax+4))
26758 (write-buffered *(ebp+0xc) %eax)
26759 58/pop-to-eax
26760 (write-buffered *(ebp+0xc) "' has non-array type\n")
26761 (flush *(ebp+0xc))
26762 (stop *(ebp+0x10) 1)
26763
26764
26765 size-of-type-id-as-array-element:
26766
26767 55/push-ebp
26768 89/<- %ebp 4/r32/esp
26769
26770 8b/-> *(ebp+8) 0/r32/eax
26771
26772 3d/compare-eax-and 8/imm32/byte
26773 {
26774 75/jump-if-!= break/disp8
26775 b8/copy-to-eax 1/imm32
26776 eb/jump $size-of-type-id-as-array-element:end/disp8
26777 }
26778
26779 (size-of-type-id %eax)
26780 $size-of-type-id-as-array-element:end:
26781
26782 89/<- %esp 5/r32/ebp
26783 5d/pop-to-ebp
26784 c3/return
26785
26786 emit-save-size-to:
26787
26788 55/push-ebp
26789 89/<- %ebp 4/r32/esp
26790
26791 50/push-eax
26792 53/push-ebx
26793
26794 8b/-> *(ebp+0xc) 3/r32/ebx
26795 (emit-indent *(ebp+8) *Curr-block-depth)
26796 (write-buffered *(ebp+8) "8b/-> *")
26797
26798 {
26799 81 7/subop/compare *(ebx+0x18)) 0/imm32
26800 74/jump-if-= break/disp8
26801 $emit-save-size-to:emit-base-from-register:
26802 (lookup *(ebx+0x18) *(ebx+0x1c))
26803 (write-buffered *(ebp+8) %eax)
26804 eb/jump $emit-save-size-to:emit-output/disp8
26805 }
26806
26807 {
26808 81 7/subop/compare *(ebx+0x14)) 0/imm32
26809 74/jump-if-= break/disp8
26810 $emit-save-size-to:emit-base-from-stack:
26811 (write-buffered *(ebp+8) "(ebp+")
26812 (write-int32-hex-buffered *(ebp+8) *(ebx+0x14))
26813 (write-buffered *(ebp+8) ")")
26814 }
26815 $emit-save-size-to:emit-output:
26816 (write-buffered *(ebp+8) " ")
26817 (get Mu-registers *(ebp+0x10) 0xc "Mu-registers")
26818 (write-int32-hex-buffered *(ebp+8) *eax)
26819 (write-buffered *(ebp+8) "/r32\n")
26820 $emit-save-size-to:end:
26821
26822 5b/pop-to-ebx
26823 58/pop-to-eax
26824
26825 89/<- %esp 5/r32/ebp
26826 5d/pop-to-ebp
26827 c3/return
26828
26829 emit-divide-by-shift-right:
26830
26831 55/push-ebp
26832 89/<- %ebp 4/r32/esp
26833
26834 50/push-eax
26835
26836 (emit-indent *(ebp+8) *Curr-block-depth)
26837 (write-buffered *(ebp+8) "c1/shift 5/subop/>> %")
26838 (write-buffered *(ebp+8) *(ebp+0xc))
26839 (write-buffered *(ebp+8) Space)
26840 (num-shift-rights *(ebp+0x10))
26841 (write-int32-hex-buffered *(ebp+8) %eax)
26842 (write-buffered *(ebp+8) "/imm8\n")
26843 $emit-divide-by-shift-right:end:
26844
26845 58/pop-to-eax
26846
26847 89/<- %esp 5/r32/ebp
26848 5d/pop-to-ebp
26849 c3/return
26850
26851
26852 translate-mu-index-stmt:
26853
26854 55/push-ebp
26855 89/<- %ebp 4/r32/esp
26856
26857 53/push-ebx
26858
26859 8b/-> *(ebp+0xc) 3/r32/ebx
26860
26861 (lookup *(ebx+0xc) *(ebx+0x10))
26862 (lookup *eax *(eax+4))
26863 89/<- %ebx 0/r32/eax
26864
26865 (emit-mu-index-bounds-check *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18))
26866
26867 {
26868 81 7/subop/compare *(ebx+0x18) 0/imm32
26869 74/jump-if-= break/disp8
26870
26871 (translate-mu-index-stmt-with-array-in-register *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18))
26872 eb/jump $translate-mu-index-stmt:end/disp8
26873 }
26874
26875 {
26876 81 7/subop/compare *(ebx+0x14) 0/imm32
26877 74/jump-if-= break/disp8
26878
26879 (translate-mu-index-stmt-with-array-on-stack *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18))
26880 eb/jump $translate-mu-index-stmt:end/disp8
26881 }
26882 $translate-mu-index-stmt:end:
26883
26884 5b/pop-to-ebx
26885
26886 89/<- %esp 5/r32/ebp
26887 5d/pop-to-ebp
26888 c3/return
26889
26890 $translate-mu-index-stmt:error1:
26891 (write-buffered *(ebp+0x14) "couldn't translate an index instruction. second (index) input must either lie in a register or be a literal\n")
26892 (flush *(ebp+0x14))
26893 (stop *(ebp+0x18) 1)
26894
26895
26896 $translate-mu-index-stmt:error2:
26897 (write-buffered *(ebp+0x14) "couldn't translate an index instruction. second (index) input when in a register must be an int or offset\n")
26898 (flush *(ebp+0x14))
26899 (stop *(ebp+0x18) 1)
26900
26901
26902 emit-mu-index-bounds-check:
26903
26904 55/push-ebp
26905 89/<- %ebp 4/r32/esp
26906
26907 50/push-eax
26908 51/push-ecx
26909 52/push-edx
26910 53/push-ebx
26911
26912 8b/-> *(ebp+0xc) 1/r32/ecx
26913
26914 (emit-indent *(ebp+8) *Curr-block-depth)
26915 (write-buffered *(ebp+8) "(__check-mu-array-bounds ")
26916 $emit-mu-index-bounds-check:compute-base:
26917
26918 (lookup *(ecx+0xc) *(ecx+0x10))
26919 (lookup *eax *(eax+4))
26920 89/<- %ebx 0/r32/eax
26921 $emit-mu-index-bounds-check:emit-index:
26922
26923 (lookup *(ecx+0xc) *(ecx+0x10))
26924 (lookup *(eax+8) *(eax+0xc))
26925 (lookup *eax *(eax+4))
26926 89/<- %edx 0/r32/eax
26927
26928 81 7/subop/compare *(edx+0x18) 0/imm32
26929 {
26930 0f 84/jump-if-= break/disp32
26931 $emit-mu-index-bounds-check:emit-register-index:
26932 (write-buffered *(ebp+8) "%")
26933 (lookup *(edx+0x18) *(edx+0x1c))
26934 (write-buffered *(ebp+8) %eax)
26935 eb/jump $emit-mu-index-bounds-check:index-done/disp8
26936 }
26937
26938 $emit-mu-index-bounds-check:emit-literal-index:
26939 (lookup *(edx+8) *(edx+0xc))
26940 (is-simple-mu-type? %eax 0)
26941 3d/compare-eax-and 0/imm32/false
26942 {
26943 0f 84/jump-if-= break/disp32
26944 (lookup *edx *(edx+4))
26945 (write-buffered *(ebp+8) %eax)
26946 }
26947 $emit-mu-index-bounds-check:index-done:
26948 (write-buffered *(ebp+8) " ")
26949 $emit-mu-index-bounds-check:emit-element-size:
26950
26951 {
26952 {
26953 (lookup *(edx+8) *(edx+0xc))
26954 (is-simple-mu-type? %eax 0)
26955 3d/compare-eax-and 0/imm32/false
26956 75/jump-if-!= break/disp8
26957 (lookup *(edx+8) *(edx+0xc))
26958 (is-simple-mu-type? %eax 1)
26959 3d/compare-eax-and 0/imm32/false
26960 75/jump-if-!= break/disp8
26961 eb/jump $emit-mu-index-bounds-check:emit-element-size-offset/disp8
26962 }
26963 $emit-mu-index-bounds-check:emit-int-register-index:
26964 (array-element-size %ebx *(ebp+0x14) *(ebp+0x18))
26965 (write-int32-hex-buffered *(ebp+8) %eax)
26966 e9/jump $emit-mu-index-bounds-check:emit-base/disp32
26967 }
26968 $emit-mu-index-bounds-check:emit-element-size-offset:
26969
26970 (lookup *(edx+8) *(edx+0xc))
26971 81 7/subop/compare *eax 0/imm32/false
26972 {
26973 75/jump-if-!= break/disp8
26974 (lookup *(eax+4) *(eax+8))
26975 (is-simple-mu-type? %eax 7)
26976 3d/compare-eax-and 0/imm32/false
26977 {
26978 0f 84/jump-if-= break/disp32
26979 $emit-mu-index-bounds-check:emit-offset-register-index:
26980 (write-buffered *(ebp+8) "1")
26981 }
26982 }
26983 $emit-mu-index-bounds-check:emit-base:
26984
26985 81 7/subop/compare *(ebx+0x18) 0/imm32
26986 {
26987 74/jump-if-= break/disp8
26988 (write-buffered *(ebp+8) " *")
26989 (lookup *(ebx+0x18) *(ebx+0x1c))
26990 (write-buffered *(ebp+8) %eax)
26991 e9/jump $emit-mu-index-bounds-check:emit-function-name/disp32
26992 }
26993
26994 (write-buffered *(ebp+8) " *(ebp+")
26995 (write-int32-hex-buffered *(ebp+8) *(ebx+0x14))
26996 (write-buffered *(ebp+8) ")")
26997 $emit-mu-index-bounds-check:emit-function-name:
26998
26999 (write-buffered *(ebp+8) " \"")
27000 8b/-> *(ebp+0x10) 1/r32/ecx
27001 (lookup *ecx *(ecx+4))
27002 (write-buffered *(ebp+8) %eax)
27003 (write-buffered *(ebp+8) "\"")
27004 $emit-mu-index-bounds-check:emit-array-name:
27005
27006 (write-buffered *(ebp+8) " \"")
27007 (lookup *ebx *(ebx+4))
27008 (write-buffered *(ebp+8) %eax)
27009 (write-buffered *(ebp+8) "\")\n")
27010 $emit-mu-index-bounds-check:end:
27011
27012 5b/pop-to-ebx
27013 5a/pop-to-edx
27014 59/pop-to-ecx
27015 58/pop-to-eax
27016
27017 89/<- %esp 5/r32/ebp
27018 5d/pop-to-ebp
27019 c3/return
27020
27021 translate-mu-index-stmt-with-array-in-register:
27022
27023 55/push-ebp
27024 89/<- %ebp 4/r32/esp
27025
27026 50/push-eax
27027 51/push-ecx
27028 52/push-edx
27029 53/push-ebx
27030
27031 (emit-indent *(ebp+8) *Curr-block-depth)
27032 (write-buffered *(ebp+8) "8d/copy-address *(")
27033
27034 $translate-mu-index-stmt-with-array-in-register:emit-base:
27035
27036 8b/-> *(ebp+0xc) 1/r32/ecx
27037
27038 (lookup *(ecx+0xc) *(ecx+0x10))
27039 (lookup *eax *(eax+4))
27040 89/<- %ebx 0/r32/eax
27041
27042 (lookup *(ebx+0x18) *(ebx+0x1c))
27043 (write-buffered *(ebp+8) %eax)
27044 (write-buffered *(ebp+8) " + ")
27045
27046 (lookup *(ecx+0xc) *(ecx+0x10))
27047 (lookup *(eax+8) *(eax+0xc))
27048 (lookup *eax *(eax+4))
27049 89/<- %edx 0/r32/eax
27050
27051 81 7/subop/compare *(edx+0x18) 0/imm32
27052 {
27053 0f 84/jump-if-= break/disp32
27054 $translate-mu-index-stmt-with-array-in-register:emit-register-index:
27055
27056 (lookup *(edx+8) *(edx+0xc))
27057 (is-simple-mu-type? %eax 1)
27058 3d/compare-eax-and 0/imm32/false
27059 {
27060 0f 84/jump-if-= break/disp32
27061 $translate-mu-index-stmt-with-array-in-register:emit-int-register-index:
27062
27063
27064 (lookup *(edx+0x18) *(edx+0x1c))
27065 (write-buffered *(ebp+8) %eax)
27066 (write-buffered *(ebp+8) "<<")
27067
27068
27069 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14))
27070 (num-shift-rights %eax)
27071 (write-int32-hex-buffered *(ebp+8) %eax)
27072 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-register-index-done/disp32
27073 }
27074
27075 (lookup *(edx+8) *(edx+0xc))
27076 81 7/subop/compare *eax 0/imm32/false
27077 0f 85/jump-if-!= $translate-mu-index-stmt:error2/disp32
27078
27079 (lookup *(eax+4) *(eax+8))
27080 (is-simple-mu-type? %eax 7)
27081 3d/compare-eax-and 0/imm32/false
27082 {
27083 0f 84/jump-if-= break/disp32
27084
27085 $translate-mu-index-stmt-with-array-in-register:emit-offset-register-index:
27086 (lookup *(edx+0x18) *(edx+0x1c))
27087 (write-buffered *(ebp+8) %eax)
27088 }
27089 $translate-mu-index-stmt-with-array-in-register:emit-register-index-done:
27090 (write-buffered *(ebp+8) " + 4) ")
27091 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-output/disp32
27092 }
27093
27094 (lookup *(edx+8) *(edx+0xc))
27095 (is-simple-mu-type? %eax 0)
27096 3d/compare-eax-and 0/imm32/false
27097 {
27098 0f 84/jump-if-= break/disp32
27099 $translate-mu-index-stmt-with-array-in-register:emit-literal-index:
27100
27101 (lookup *edx *(edx+4))
27102 (parse-hex-int %eax)
27103 89/<- %edx 0/r32/eax
27104
27105 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14))
27106 f7 4/subop/multiply-into-edx-eax %edx
27107
27108 05/add-to-eax 4/imm32
27109
27110
27111 (write-int32-hex-buffered *(ebp+8) %eax)
27112 (write-buffered *(ebp+8) ") ")
27113 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-output/disp32
27114 }
27115
27116 e9/jump $translate-mu-index-stmt:error1/disp32
27117 $translate-mu-index-stmt-with-array-in-register:emit-output:
27118
27119 8b/-> *(ebp+0xc) 1/r32/ecx
27120 (lookup *(ecx+0x14) *(ecx+0x18))
27121 (lookup *eax *(eax+4))
27122 (lookup *(eax+0x18) *(eax+0x1c))
27123 (get Mu-registers %eax 0xc "Mu-registers")
27124 (write-int32-hex-buffered *(ebp+8) *eax)
27125 (write-buffered *(ebp+8) "/r32\n")
27126 $translate-mu-index-stmt-with-array-in-register:end:
27127
27128 5b/pop-to-ebx
27129 5a/pop-to-edx
27130 59/pop-to-ecx
27131 58/pop-to-eax
27132
27133 89/<- %esp 5/r32/ebp
27134 5d/pop-to-ebp
27135 c3/return
27136
27137 translate-mu-index-stmt-with-array-on-stack:
27138
27139 55/push-ebp
27140 89/<- %ebp 4/r32/esp
27141
27142 50/push-eax
27143 51/push-ecx
27144 52/push-edx
27145 53/push-ebx
27146
27147 (emit-indent *(ebp+8) *Curr-block-depth)
27148 (write-buffered *(ebp+8) "8d/copy-address *(ebp + ")
27149
27150 8b/-> *(ebp+0xc) 0/r32/eax
27151 (lookup *(eax+0xc) *(eax+0x10))
27152 89/<- %edx 0/r32/eax
27153
27154 (lookup *eax *(eax+4))
27155 89/<- %ecx 0/r32/eax
27156
27157 (lookup *(edx+8) *(edx+0xc))
27158
27159 (lookup *eax *(eax+4))
27160 89/<- %edx 0/r32/eax
27161
27162 81 7/subop/compare *(edx+0x18) 0/imm32
27163 {
27164 0f 84/jump-if-= break/disp32
27165 $translate-mu-index-stmt-with-array-on-stack:emit-register-index:
27166
27167 (lookup *(edx+8) *(edx+0xc))
27168 (is-simple-mu-type? %eax 1)
27169 3d/compare-eax-and 0/imm32/false
27170 {
27171 0f 84/jump-if-= break/disp32
27172 $translate-mu-index-stmt-with-array-on-stack:emit-int-register-index:
27173
27174
27175 (lookup *(edx+0x18) *(edx+0x1c))
27176 (write-buffered *(ebp+8) %eax)
27177 (write-buffered *(ebp+8) "<<")
27178
27179
27180 (array-element-size %ecx *(ebp+0x10) *(ebp+0x14))
27181 (num-shift-rights %eax)
27182 (write-int32-hex-buffered *(ebp+8) %eax)
27183
27184 (write-buffered *(ebp+8) " + ")
27185
27186 8b/-> *(ecx+0x14) 0/r32/eax
27187 05/add-to-eax 4/imm32
27188 (write-int32-hex-buffered *(ebp+8) %eax)
27189 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-register-index-done/disp32
27190 }
27191
27192 (lookup *(edx+8) *(edx+0xc))
27193 81 7/subop/compare *eax 0/imm32/false
27194 0f 85/jump-if-!= $translate-mu-index-stmt:error2/disp32
27195
27196 (lookup *(eax+4) *(eax+8))
27197 (is-simple-mu-type? %eax 7)
27198 3d/compare-eax-and 0/imm32/false
27199 {
27200 0f 84/jump-if-= break/disp32
27201
27202 $translate-mu-index-stmt-with-array-on-stack:emit-offset-register-index:
27203 (lookup *(edx+0x18) *(edx+0x1c))
27204 (write-buffered *(ebp+8) %eax)
27205 }
27206 $translate-mu-index-stmt-with-array-on-stack:emit-register-index-done:
27207 (write-buffered *(ebp+8) ") ")
27208 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-output/disp32
27209 }
27210
27211 (lookup *(edx+8) *(edx+0xc))
27212 (is-simple-mu-type? %eax 0)
27213 3d/compare-eax-and 0/imm32/false
27214 {
27215 0f 84/jump-if-= break/disp32
27216 $translate-mu-index-stmt-with-array-on-stack:emit-literal-index:
27217
27218 (lookup *edx *(edx+4))
27219 (parse-hex-int %eax)
27220 89/<- %edx 0/r32/eax
27221
27222 (array-element-size %ecx *(ebp+0x10) *(ebp+0x14))
27223 f7 4/subop/multiply-into-edx-eax %edx
27224
27225 03/add *(ecx+0x14) 0/r32/eax
27226
27227 05/add-to-eax 4/imm32
27228
27229
27230 (write-int32-hex-buffered *(ebp+8) %eax)
27231 (write-buffered *(ebp+8) ") ")
27232 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-output/disp32
27233 }
27234
27235 e9/jump $translate-mu-index-stmt:error1/disp32
27236 $translate-mu-index-stmt-with-array-on-stack:emit-output:
27237
27238 8b/-> *(ebp+0xc) 0/r32/eax
27239 (lookup *(eax+0x14) *(eax+0x18))
27240 (lookup *eax *(eax+4))
27241 (lookup *(eax+0x18) *(eax+0x1c))
27242 (get Mu-registers %eax 0xc "Mu-registers")
27243 (write-int32-hex-buffered *(ebp+8) *eax)
27244 (write-buffered *(ebp+8) "/r32\n")
27245 $translate-mu-index-stmt-with-array-on-stack:end:
27246
27247 5b/pop-to-ebx
27248 5a/pop-to-edx
27249 59/pop-to-ecx
27250 58/pop-to-eax
27251
27252 89/<- %esp 5/r32/ebp
27253 5d/pop-to-ebp
27254 c3/return
27255
27256 translate-mu-compute-index-stmt:
27257
27258 55/push-ebp
27259 89/<- %ebp 4/r32/esp
27260
27261 50/push-eax
27262 51/push-ecx
27263 52/push-edx
27264 53/push-ebx
27265
27266 (emit-indent *(ebp+8) *Curr-block-depth)
27267 (write-buffered *(ebp+8) "69/multiply")
27268
27269 8b/-> *(ebp+0xc) 1/r32/ecx
27270
27271 (lookup *(ecx+0xc) *(ecx+0x10))
27272 89/<- %ebx 0/r32/eax
27273 $translate-mu-compute-index-stmt:emit-index:
27274 (lookup *(ebx+8) *(ebx+0xc))
27275 (emit-subx-var-as-rm32 *(ebp+8) %eax)
27276 (write-buffered *(ebp+8) Space)
27277 $translate-mu-compute-index-stmt:emit-elem-size:
27278
27279 (lookup *ebx *(ebx+4))
27280 89/<- %ebx 0/r32/eax
27281
27282 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14))
27283 (write-int32-hex-buffered *(ebp+8) %eax)
27284 (write-buffered *(ebp+8) "/imm32 ")
27285 $translate-mu-compute-index-stmt:emit-output:
27286
27287 (lookup *(ecx+0x14) *(ecx+0x18))
27288 (lookup *eax *(eax+4))
27289 (lookup *(eax+0x18) *(eax+0x1c))
27290 (get Mu-registers %eax 0xc "Mu-registers")
27291 (write-int32-hex-buffered *(ebp+8) *eax)
27292 (write-buffered *(ebp+8) "/r32\n")
27293 $translate-mu-compute-index-stmt:end:
27294
27295 5b/pop-to-ebx
27296 5a/pop-to-edx
27297 59/pop-to-ecx
27298 58/pop-to-eax
27299
27300 89/<- %esp 5/r32/ebp
27301 5d/pop-to-ebp
27302 c3/return
27303
27304 translate-mu-get-stmt:
27305
27306 55/push-ebp
27307 89/<- %ebp 4/r32/esp
27308
27309 50/push-eax
27310 51/push-ecx
27311 52/push-edx
27312
27313 (emit-indent *(ebp+8) *Curr-block-depth)
27314 (write-buffered *(ebp+8) "8d/copy-address ")
27315
27316 8b/-> *(ebp+0xc) 1/r32/ecx
27317
27318 (mu-get-offset %ecx)
27319 89/<- %edx 0/r32/eax
27320
27321 (lookup *(ecx+0xc) *(ecx+0x10))
27322 (lookup *eax *(eax+4))
27323
27324 81 7/subop/compare *(eax+0x18) 0/imm32
27325 {
27326 0f 84/jump-if-= break/disp32
27327 $translate-mu-get-stmt:emit-register-input:
27328
27329 (write-buffered *(ebp+8) "*(")
27330 (lookup *(eax+0x18) *(eax+0x1c))
27331 (write-buffered *(ebp+8) %eax)
27332 (write-buffered *(ebp+8) " + ")
27333 (write-int32-hex-buffered *(ebp+8) %edx)
27334 (write-buffered *(ebp+8) ") ")
27335 e9/jump $translate-mu-get-stmt:emit-output/disp32
27336 }
27337
27338 {
27339 $translate-mu-get-stmt:emit-stack-input:
27340
27341 (write-buffered *(ebp+8) "*(ebp+")
27342 03/add *(eax+0x14) 2/r32/edx
27343 (write-int32-hex-buffered *(ebp+8) %edx)
27344 (write-buffered *(ebp+8) ") ")
27345 eb/jump $translate-mu-get-stmt:emit-output/disp8
27346 }
27347 $translate-mu-get-stmt:emit-output:
27348
27349 (lookup *(ecx+0x14) *(ecx+0x18))
27350 (lookup *eax *(eax+4))
27351
27352 (lookup *(eax+0x18) *(eax+0x1c))
27353 (get Mu-registers %eax 0xc "Mu-registers")
27354 (write-int32-hex-buffered *(ebp+8) *eax)
27355 (write-buffered *(ebp+8) "/r32\n")
27356 $translate-mu-get-stmt:end:
27357
27358 5a/pop-to-edx
27359 59/pop-to-ecx
27360 58/pop-to-eax
27361
27362 89/<- %esp 5/r32/ebp
27363 5d/pop-to-ebp
27364 c3/return
27365
27366 translate-mu-copy-object-stmt:
27367
27368 55/push-ebp
27369 89/<- %ebp 4/r32/esp
27370
27371 50/push-eax
27372
27373 (emit-indent *(ebp+8) *Curr-block-depth)
27374 (write-buffered *(ebp+8) "(copy-bytes")
27375
27376 8b/-> *(ebp+0xc) 0/r32/eax
27377
27378 (lookup *(eax+0xc) *(eax+0x10))
27379 (emit-subx-call-operand *(ebp+8) %eax)
27380
27381 (lookup *(eax+8) *(eax+0xc))
27382 (emit-subx-call-operand *(ebp+8) %eax)
27383
27384 (write-buffered *(ebp+8) Space)
27385 (addr-payload-size %eax *(ebp+0x10) *(ebp+0x14))
27386 (write-int32-hex-buffered *(ebp+8) %eax)
27387 (write-buffered *(ebp+8) ")\n")
27388 $translate-mu-copy-object-stmt:end:
27389
27390 58/pop-to-eax
27391
27392 89/<- %esp 5/r32/ebp
27393 5d/pop-to-ebp
27394 c3/return
27395
27396 translate-mu-clear-object-stmt:
27397
27398 55/push-ebp
27399 89/<- %ebp 4/r32/esp
27400
27401 50/push-eax
27402
27403 (emit-indent *(ebp+8) *Curr-block-depth)
27404 (write-buffered *(ebp+8) "(zero-out")
27405
27406 8b/-> *(ebp+0xc) 0/r32/eax
27407
27408 (lookup *(eax+0xc) *(eax+0x10))
27409
27410 (emit-subx-call-operand *(ebp+8) %eax)
27411 (write-buffered *(ebp+8) Space)
27412 (addr-payload-size %eax *(ebp+0x10) *(ebp+0x14))
27413 (write-int32-hex-buffered *(ebp+8) %eax)
27414 (write-buffered *(ebp+8) ")\n")
27415 $translate-mu-clear-object-stmt:end:
27416
27417 58/pop-to-eax
27418
27419 89/<- %esp 5/r32/ebp
27420 5d/pop-to-ebp
27421 c3/return
27422
27423 translate-mu-allocate-stmt:
27424
27425 55/push-ebp
27426 89/<- %ebp 4/r32/esp
27427
27428 50/push-eax
27429 56/push-esi
27430 57/push-edi
27431
27432 8b/-> *(ebp+0xc) 6/r32/esi
27433
27434 (lookup *(esi+0xc) *(esi+0x10))
27435 89/<- %edi 0/r32/eax
27436
27437 (emit-indent *(ebp+8) *Curr-block-depth)
27438 (write-buffered *(ebp+8) "(allocate Heap ")
27439 (addr-handle-payload-size %edi *(ebp+0x10) *(ebp+0x14))
27440 (write-int32-hex-buffered *(ebp+8) %eax)
27441 (emit-subx-call-operand *(ebp+8) %edi)
27442 (write-buffered *(ebp+8) ")\n")
27443 $translate-mu-allocate-stmt:end:
27444
27445 5f/pop-to-edi
27446 5e/pop-to-esi
27447 58/pop-to-eax
27448
27449 89/<- %esp 5/r32/ebp
27450 5d/pop-to-ebp
27451 c3/return
27452
27453 addr-handle-payload-size:
27454
27455 55/push-ebp
27456 89/<- %ebp 4/r32/esp
27457
27458 8b/-> *(ebp+8) 0/r32/eax
27459 (lookup *eax *(eax+4))
27460 (lookup *(eax+8) *(eax+0xc))
27461
27462
27463
27464
27465 $addr-handle-payload-size:skip-addr:
27466 (lookup *(eax+0xc) *(eax+0x10))
27467
27468
27469
27470
27471 $addr-handle-payload-size:skip-handle:
27472 (lookup *(eax+0xc) *(eax+0x10))
27473
27474
27475 81 7/subop/compare *eax 0/imm32/false
27476 {
27477 75/jump-if-!= break/disp8
27478 (lookup *(eax+4) *(eax+8))
27479 }
27480
27481
27482 (size-of-type-id *(eax+4))
27483 $addr-handle-payload-size:end:
27484
27485 89/<- %esp 5/r32/ebp
27486 5d/pop-to-ebp
27487 c3/return
27488
27489 addr-payload-size:
27490
27491 55/push-ebp
27492 89/<- %ebp 4/r32/esp
27493
27494 8b/-> *(ebp+8) 0/r32/eax
27495 (lookup *eax *(eax+4))
27496 (lookup *(eax+8) *(eax+0xc))
27497
27498
27499
27500
27501 $addr-payload-size:skip-addr:
27502 (lookup *(eax+0xc) *(eax+0x10))
27503
27504
27505 81 7/subop/compare *eax 0/imm32/false
27506 {
27507 75/jump-if-!= break/disp8
27508 (lookup *(eax+4) *(eax+8))
27509 }
27510
27511
27512 (size-of-type-id *(eax+4))
27513 $addr-payload-size:end:
27514
27515 89/<- %esp 5/r32/ebp
27516 5d/pop-to-ebp
27517 c3/return
27518
27519 translate-mu-populate-stmt:
27520
27521 55/push-ebp
27522 89/<- %ebp 4/r32/esp
27523
27524 50/push-eax
27525 51/push-ecx
27526 56/push-esi
27527 57/push-edi
27528
27529 8b/-> *(ebp+0xc) 6/r32/esi
27530
27531 (lookup *(esi+0xc) *(esi+0x10))
27532 89/<- %edi 0/r32/eax
27533
27534 (lookup *(edi+8) *(edi+0xc))
27535 89/<- %ecx 0/r32/eax
27536
27537 (emit-indent *(ebp+8) *Curr-block-depth)
27538 (write-buffered *(ebp+8) "(allocate-array2 Heap ")
27539 (addr-handle-array-payload-size %edi *(ebp+0x10) *(ebp+0x14))
27540 (write-int32-hex-buffered *(ebp+8) %eax)
27541 (emit-subx-call-operand *(ebp+8) %ecx)
27542 (emit-subx-call-operand *(ebp+8) %edi)
27543 (write-buffered *(ebp+8) ")\n")
27544 $translate-mu-populate-stmt:end:
27545
27546 5f/pop-to-edi
27547 5e/pop-to-esi
27548 59/pop-to-ecx
27549 58/pop-to-eax
27550
27551 89/<- %esp 5/r32/ebp
27552 5d/pop-to-ebp
27553 c3/return
27554
27555 translate-mu-populate-stream-stmt:
27556
27557 55/push-ebp
27558 89/<- %ebp 4/r32/esp
27559
27560 50/push-eax
27561 51/push-ecx
27562 56/push-esi
27563 57/push-edi
27564
27565 8b/-> *(ebp+0xc) 6/r32/esi
27566
27567 (lookup *(esi+0xc) *(esi+0x10))
27568 89/<- %edi 0/r32/eax
27569
27570 (lookup *(edi+8) *(edi+0xc))
27571 89/<- %ecx 0/r32/eax
27572
27573 (emit-indent *(ebp+8) *Curr-block-depth)
27574 (write-buffered *(ebp+8) "(new-stream Heap ")
27575 (addr-handle-stream-payload-size %edi *(ebp+0x10) *(ebp+0x14))
27576 (write-int32-hex-buffered *(ebp+8) %eax)
27577 (emit-subx-call-operand *(ebp+8) %ecx)
27578 (emit-subx-call-operand *(ebp+8) %edi)
27579 (write-buffered *(ebp+8) ")\n")
27580 $translate-mu-populate-stream-stmt:end:
27581
27582 5f/pop-to-edi
27583 5e/pop-to-esi
27584 59/pop-to-ecx
27585 58/pop-to-eax
27586
27587 89/<- %esp 5/r32/ebp
27588 5d/pop-to-ebp
27589 c3/return
27590
27591 translate-mu-read-from-stream-stmt:
27592
27593 55/push-ebp
27594 89/<- %ebp 4/r32/esp
27595
27596 50/push-eax
27597 51/push-ecx
27598 56/push-esi
27599 57/push-edi
27600
27601 8b/-> *(ebp+0xc) 6/r32/esi
27602
27603 (lookup *(esi+0xc) *(esi+0x10))
27604 89/<- %ecx 0/r32/eax
27605
27606 (lookup *(ecx+8) *(ecx+0xc))
27607 89/<- %edi 0/r32/eax
27608
27609 (emit-indent *(ebp+8) *Curr-block-depth)
27610 (write-buffered *(ebp+8) "(read-from-stream")
27611 (emit-subx-call-operand *(ebp+8) %ecx)
27612 (emit-subx-call-operand *(ebp+8) %edi)
27613 (write-buffered *(ebp+8) Space)
27614 (addr-payload-size %edi *(ebp+0x10) *(ebp+0x14))
27615 (write-int32-hex-buffered *(ebp+8) %eax)
27616 (write-buffered *(ebp+8) ")\n")
27617 $translate-mu-read-from-stream-stmt:end:
27618
27619 5f/pop-to-edi
27620 5e/pop-to-esi
27621 59/pop-to-ecx
27622 58/pop-to-eax
27623
27624 89/<- %esp 5/r32/ebp
27625 5d/pop-to-ebp
27626 c3/return
27627
27628 translate-mu-write-to-stream-stmt:
27629
27630 55/push-ebp
27631 89/<- %ebp 4/r32/esp
27632
27633 50/push-eax
27634 51/push-ecx
27635 56/push-esi
27636 57/push-edi
27637
27638 8b/-> *(ebp+0xc) 6/r32/esi
27639
27640 (lookup *(esi+0xc) *(esi+0x10))
27641 89/<- %ecx 0/r32/eax
27642
27643 (lookup *(ecx+8) *(ecx+0xc))
27644 89/<- %edi 0/r32/eax
27645
27646 (emit-indent *(ebp+8) *Curr-block-depth)
27647 (write-buffered *(ebp+8) "(write-to-stream")
27648 (emit-subx-call-operand *(ebp+8) %ecx)
27649 (flush *(ebp+8))
27650 (emit-subx-call-operand *(ebp+8) %edi)
27651 (flush *(ebp+8))
27652 (write-buffered *(ebp+8) Space)
27653 (flush *(ebp+8))
27654 (addr-payload-size %edi *(ebp+0x10) *(ebp+0x14))
27655 (write-int32-hex-buffered *(ebp+8) %eax)
27656 (write-buffered *(ebp+8) ")\n")
27657 $translate-mu-write-to-stream-stmt:end:
27658
27659 5f/pop-to-edi
27660 5e/pop-to-esi
27661 59/pop-to-ecx
27662 58/pop-to-eax
27663
27664 89/<- %esp 5/r32/ebp
27665 5d/pop-to-ebp
27666 c3/return
27667
27668 addr-handle-array-payload-size:
27669
27670 55/push-ebp
27671 89/<- %ebp 4/r32/esp
27672
27673 8b/-> *(ebp+8) 0/r32/eax
27674 (lookup *eax *(eax+4))
27675 (lookup *(eax+8) *(eax+0xc))
27676
27677
27678
27679
27680 $addr-handle-array-payload-size:skip-addr:
27681 (lookup *(eax+0xc) *(eax+0x10))
27682
27683
27684
27685
27686 $addr-handle-array-payload-size:skip-handle:
27687 (lookup *(eax+0xc) *(eax+0x10))
27688
27689
27690
27691
27692 $addr-handle-array-payload-size:skip-array:
27693 (lookup *(eax+0xc) *(eax+0x10))
27694
27695
27696 81 7/subop/compare *eax 0/imm32/false
27697 {
27698 75/jump-if-!= break/disp8
27699 (lookup *(eax+4) *(eax+8))
27700 }
27701 $addr-handle-array-payload-size:compute-size:
27702
27703
27704 (size-of-type-id-as-array-element *(eax+4))
27705 $addr-handle-array-payload-size:end:
27706
27707 89/<- %esp 5/r32/ebp
27708 5d/pop-to-ebp
27709 c3/return
27710
27711 addr-handle-stream-payload-size:
27712
27713 55/push-ebp
27714 89/<- %ebp 4/r32/esp
27715
27716 8b/-> *(ebp+8) 0/r32/eax
27717 (lookup *eax *(eax+4))
27718 (lookup *(eax+8) *(eax+0xc))
27719
27720
27721
27722
27723 $addr-handle-stream-payload-size:skip-addr:
27724 (lookup *(eax+0xc) *(eax+0x10))
27725
27726
27727
27728
27729 $addr-handle-stream-payload-size:skip-handle:
27730 (lookup *(eax+0xc) *(eax+0x10))
27731
27732
27733
27734
27735 $addr-handle-stream-payload-size:skip-stream:
27736 (lookup *(eax+0xc) *(eax+0x10))
27737
27738
27739 81 7/subop/compare *eax 0/imm32/false
27740 {
27741 75/jump-if-!= break/disp8
27742 (lookup *(eax+4) *(eax+8))
27743 }
27744 $addr-handle-stream-payload-size:compute-size:
27745
27746
27747 (size-of-type-id-as-array-element *(eax+4))
27748 $addr-handle-stream-payload-size:end:
27749
27750 89/<- %esp 5/r32/ebp
27751 5d/pop-to-ebp
27752 c3/return
27753
27754 power-of-2?:
27755
27756
27757 55/push-ebp
27758 89/<- %ebp 4/r32/esp
27759
27760 8b/-> *(ebp+8) 0/r32/eax
27761
27762 3d/compare-eax-with 0/imm32
27763 0f 8c/jump-if-< $power-of-2?:abort/disp32
27764
27765 48/decrement-eax
27766
27767 23/and-> *(ebp+8) 0/r32/eax
27768
27769 3d/compare-eax-and 0/imm32
27770 0f 94/set-byte-if-= %al
27771 81 4/subop/and %eax 0xff/imm32
27772 $power-of-2?:end:
27773
27774 89/<- %esp 5/r32/ebp
27775 5d/pop-to-ebp
27776 c3/return
27777
27778 $power-of-2?:abort:
27779 (write-buffered *(ebp+0xc) "power-of-2?: negative number\n")
27780 (flush *(ebp+0xc))
27781 (stop *(ebp+0x10) 1)
27782
27783
27784 num-shift-rights:
27785
27786
27787 55/push-ebp
27788 89/<- %ebp 4/r32/esp
27789
27790 51/push-ecx
27791
27792 8b/-> *(ebp+8) 1/r32/ecx
27793
27794 b8/copy-to-eax 0/imm32
27795 {
27796
27797 81 7/subop/compare %ecx 1/imm32
27798 7e/jump-if-<= break/disp8
27799 40/increment-eax
27800 c1/shift 5/subop/arithmetic-right %ecx 1/imm8
27801 eb/jump loop/disp8
27802 }
27803 $num-shift-rights:end:
27804
27805 59/pop-to-ecx
27806
27807 89/<- %esp 5/r32/ebp
27808 5d/pop-to-ebp
27809 c3/return
27810
27811 mu-get-offset:
27812
27813 55/push-ebp
27814 89/<- %ebp 4/r32/esp
27815
27816 8b/-> *(ebp+8) 0/r32/eax
27817 (lookup *(eax+0xc) *(eax+0x10))
27818 (lookup *(eax+8) *(eax+0xc))
27819
27820 (lookup *eax *(eax+4))
27821
27822
27823
27824
27825
27826
27827
27828
27829
27830
27831 8b/-> *(eax+0x14) 0/r32/eax
27832
27833
27834
27835
27836 $emit-get-offset:end:
27837
27838 89/<- %esp 5/r32/ebp
27839 5d/pop-to-ebp
27840 c3/return
27841
27842 emit-subx-block:
27843
27844 55/push-ebp
27845 89/<- %ebp 4/r32/esp
27846
27847 50/push-eax
27848 51/push-ecx
27849 56/push-esi
27850
27851 8b/-> *(ebp+0xc) 6/r32/esi
27852
27853 (lookup *(esi+0xc) *(esi+0x10))
27854 8b/-> *Curr-block-depth 1/r32/ecx
27855 89/<- *(eax+0x10) 1/r32/ecx
27856
27857 (lookup *(esi+4) *(esi+8))
27858
27859 {
27860 $emit-subx-block:check-empty:
27861 3d/compare-eax-and 0/imm32
27862 0f 84/jump-if-= break/disp32
27863 (emit-indent *(ebp+8) *Curr-block-depth)
27864 (write-buffered *(ebp+8) "{\n")
27865
27866 (lookup *(esi+0xc) *(esi+0x10))
27867 89/<- %ecx 0/r32/eax
27868
27869 (lookup *ecx *(ecx+4))
27870 (write-buffered *(ebp+8) %eax)
27871 (write-buffered *(ebp+8) ":loop:\n")
27872 ff 0/subop/increment *Curr-block-depth
27873 (push *(ebp+0x10) *(esi+0xc))
27874 (push *(ebp+0x10) *(esi+0x10))
27875 (push *(ebp+0x10) 0)
27876
27877 (lookup *(esi+4) *(esi+8))
27878 (emit-subx-stmt-list *(ebp+8) %eax *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c))
27879 (pop *(ebp+0x10))
27880 (pop *(ebp+0x10))
27881 (pop *(ebp+0x10))
27882 ff 1/subop/decrement *Curr-block-depth
27883 (emit-indent *(ebp+8) *Curr-block-depth)
27884 (write-buffered *(ebp+8) "}\n")
27885 (lookup *ecx *(ecx+4))
27886 (write-buffered *(ebp+8) %eax)
27887 (write-buffered *(ebp+8) ":break:\n")
27888 }
27889 $emit-subx-block:end:
27890
27891 5e/pop-to-esi
27892 59/pop-to-ecx
27893 58/pop-to-eax
27894
27895 89/<- %esp 5/r32/ebp
27896 5d/pop-to-ebp
27897 c3/return
27898
27899
27900
27901
27902
27903
27904
27905
27906
27907
27908
27909
27910
27911
27912
27913
27914
27915
27916
27917
27918
27919
27920
27921
27922
27923
27924
27925
27926
27927
27928
27929
27930
27931
27932
27933
27934
27935
27936
27937
27938
27939
27940
27941
27942
27943
27944
27945
27946
27947
27948 == data
27949 Primitives:
27950
27951 _Primitive-increment-eax:
27952
27953 0x11/imm32/alloc-id:fake
27954 _string-increment/imm32/name
27955 0/imm32/no-inouts
27956 0/imm32/no-inouts
27957 0x11/imm32/alloc-id:fake
27958 Single-int-var-in-eax/imm32/outputs
27959 0x11/imm32/alloc-id:fake
27960 _string_40_increment_eax/imm32/subx-name
27961 0/imm32/no-rm32
27962 0/imm32/no-r32
27963 0/imm32/no-imm32
27964 0/imm32/no-imm8
27965 0/imm32/no-disp32
27966 0/imm32/no-xm32
27967 0/imm32/no-x32
27968 0x11/imm32/alloc-id:fake
27969 _Primitive-increment-ecx/imm32/next
27970 _Primitive-increment-ecx:
27971 0x11/imm32/alloc-id:fake:payload
27972
27973 0x11/imm32/alloc-id:fake
27974 _string-increment/imm32/name
27975 0/imm32/no-inouts
27976 0/imm32/no-inouts
27977 0x11/imm32/alloc-id:fake
27978 Single-int-var-in-ecx/imm32/outputs
27979 0x11/imm32/alloc-id:fake
27980 _string_41_increment_ecx/imm32/subx-name
27981 0/imm32/no-rm32
27982 0/imm32/no-r32
27983 0/imm32/no-imm32
27984 0/imm32/no-imm8
27985 0/imm32/no-disp32
27986 0/imm32/no-xm32
27987 0/imm32/no-x32
27988 0x11/imm32/alloc-id:fake
27989 _Primitive-increment-edx/imm32/next
27990 _Primitive-increment-edx:
27991 0x11/imm32/alloc-id:fake:payload
27992
27993 0x11/imm32/alloc-id:fake
27994 _string-increment/imm32/name
27995 0/imm32/no-inouts
27996 0/imm32/no-inouts
27997 0x11/imm32/alloc-id:fake
27998 Single-int-var-in-edx/imm32/outputs
27999 0x11/imm32/alloc-id:fake
28000 _string_42_increment_edx/imm32/subx-name
28001 0/imm32/no-rm32
28002 0/imm32/no-r32
28003 0/imm32/no-imm32
28004 0/imm32/no-imm8
28005 0/imm32/no-disp32
28006 0/imm32/no-xm32
28007 0/imm32/no-x32
28008 0x11/imm32/alloc-id:fake
28009 _Primitive-increment-ebx/imm32/next
28010 _Primitive-increment-ebx:
28011 0x11/imm32/alloc-id:fake:payload
28012
28013 0x11/imm32/alloc-id:fake
28014 _string-increment/imm32/name
28015 0/imm32/no-inouts
28016 0/imm32/no-inouts
28017 0x11/imm32/alloc-id:fake
28018 Single-int-var-in-ebx/imm32/outputs
28019 0x11/imm32/alloc-id:fake
28020 _string_43_increment_ebx/imm32/subx-name
28021 0/imm32/no-rm32
28022 0/imm32/no-r32
28023 0/imm32/no-imm32
28024 0/imm32/no-imm8
28025 0/imm32/no-disp32
28026 0/imm32/no-xm32
28027 0/imm32/no-x32
28028 0x11/imm32/alloc-id:fake
28029 _Primitive-increment-esi/imm32/next
28030 _Primitive-increment-esi:
28031 0x11/imm32/alloc-id:fake:payload
28032
28033 0x11/imm32/alloc-id:fake
28034 _string-increment/imm32/name
28035 0/imm32/no-inouts
28036 0/imm32/no-inouts
28037 0x11/imm32/alloc-id:fake
28038 Single-int-var-in-esi/imm32/outputs
28039 0x11/imm32/alloc-id:fake
28040 _string_46_increment_esi/imm32/subx-name
28041 0/imm32/no-rm32
28042 0/imm32/no-r32
28043 0/imm32/no-imm32
28044 0/imm32/no-imm8
28045 0/imm32/no-disp32
28046 0/imm32/no-xm32
28047 0/imm32/no-x32
28048 0x11/imm32/alloc-id:fake
28049 _Primitive-increment-edi/imm32/next
28050 _Primitive-increment-edi:
28051 0x11/imm32/alloc-id:fake:payload
28052
28053 0x11/imm32/alloc-id:fake
28054 _string-increment/imm32/name
28055 0/imm32/no-inouts
28056 0/imm32/no-inouts
28057 0x11/imm32/alloc-id:fake
28058 Single-int-var-in-edi/imm32/outputs
28059 0x11/imm32/alloc-id:fake
28060 _string_47_increment_edi/imm32/subx-name
28061 0/imm32/no-rm32
28062 0/imm32/no-r32
28063 0/imm32/no-imm32
28064 0/imm32/no-imm8
28065 0/imm32/no-disp32
28066 0/imm32/no-xm32
28067 0/imm32/no-x32
28068 0x11/imm32/alloc-id:fake
28069 _Primitive-decrement-eax/imm32/next
28070 _Primitive-decrement-eax:
28071 0x11/imm32/alloc-id:fake:payload
28072
28073 0x11/imm32/alloc-id:fake
28074 _string-decrement/imm32/name
28075 0/imm32/no-inouts
28076 0/imm32/no-inouts
28077 0x11/imm32/alloc-id:fake
28078 Single-int-var-in-eax/imm32/outputs
28079 0x11/imm32/alloc-id:fake
28080 _string_48_decrement_eax/imm32/subx-name
28081 0/imm32/no-rm32
28082 0/imm32/no-r32
28083 0/imm32/no-imm32
28084 0/imm32/no-imm8
28085 0/imm32/no-disp32
28086 0/imm32/no-xm32
28087 0/imm32/no-x32
28088 0x11/imm32/alloc-id:fake
28089 _Primitive-decrement-ecx/imm32/next
28090 _Primitive-decrement-ecx:
28091 0x11/imm32/alloc-id:fake:payload
28092
28093 0x11/imm32/alloc-id:fake
28094 _string-decrement/imm32/name
28095 0/imm32/no-inouts
28096 0/imm32/no-inouts
28097 0x11/imm32/alloc-id:fake
28098 Single-int-var-in-ecx/imm32/outputs
28099 0x11/imm32/alloc-id:fake
28100 _string_49_decrement_ecx/imm32/subx-name
28101 0/imm32/no-rm32
28102 0/imm32/no-r32
28103 0/imm32/no-imm32
28104 0/imm32/no-imm8
28105 0/imm32/no-disp32
28106 0/imm32/no-xm32
28107 0/imm32/no-x32
28108 0x11/imm32/alloc-id:fake
28109 _Primitive-decrement-edx/imm32/next
28110 _Primitive-decrement-edx:
28111 0x11/imm32/alloc-id:fake:payload
28112
28113 0x11/imm32/alloc-id:fake
28114 _string-decrement/imm32/name
28115 0/imm32/no-inouts
28116 0/imm32/no-inouts
28117 0x11/imm32/alloc-id:fake
28118 Single-int-var-in-edx/imm32/outputs
28119 0x11/imm32/alloc-id:fake
28120 _string_4a_decrement_edx/imm32/subx-name
28121 0/imm32/no-rm32
28122 0/imm32/no-r32
28123 0/imm32/no-imm32
28124 0/imm32/no-imm8
28125 0/imm32/no-disp32
28126 0/imm32/no-xm32
28127 0/imm32/no-x32
28128 0x11/imm32/alloc-id:fake
28129 _Primitive-decrement-ebx/imm32/next
28130 _Primitive-decrement-ebx:
28131 0x11/imm32/alloc-id:fake:payload
28132
28133 0x11/imm32/alloc-id:fake
28134 _string-decrement/imm32/name
28135 0/imm32/no-inouts
28136 0/imm32/no-inouts
28137 0x11/imm32/alloc-id:fake
28138 Single-int-var-in-ebx/imm32/outputs
28139 0x11/imm32/alloc-id:fake
28140 _string_4b_decrement_ebx/imm32/subx-name
28141 0/imm32/no-rm32
28142 0/imm32/no-r32
28143 0/imm32/no-imm32
28144 0/imm32/no-imm8
28145 0/imm32/no-disp32
28146 0/imm32/no-xm32
28147 0/imm32/no-x32
28148 0x11/imm32/alloc-id:fake
28149 _Primitive-decrement-esi/imm32/next
28150 _Primitive-decrement-esi:
28151 0x11/imm32/alloc-id:fake:payload
28152
28153 0x11/imm32/alloc-id:fake
28154 _string-decrement/imm32/name
28155 0/imm32/no-inouts
28156 0/imm32/no-inouts
28157 0x11/imm32/alloc-id:fake
28158 Single-int-var-in-esi/imm32/outputs
28159 0x11/imm32/alloc-id:fake
28160 _string_4e_decrement_esi/imm32/subx-name
28161 0/imm32/no-rm32
28162 0/imm32/no-r32
28163 0/imm32/no-imm32
28164 0/imm32/no-imm8
28165 0/imm32/no-disp32
28166 0/imm32/no-xm32
28167 0/imm32/no-x32
28168 0x11/imm32/alloc-id:fake
28169 _Primitive-decrement-edi/imm32/next
28170 _Primitive-decrement-edi:
28171 0x11/imm32/alloc-id:fake:payload
28172
28173 0x11/imm32/alloc-id:fake
28174 _string-decrement/imm32/name
28175 0/imm32/no-inouts
28176 0/imm32/no-inouts
28177 0x11/imm32/alloc-id:fake
28178 Single-int-var-in-edi/imm32/outputs
28179 0x11/imm32/alloc-id:fake
28180 _string_4f_decrement_edi/imm32/subx-name
28181 0/imm32/no-rm32
28182 0/imm32/no-r32
28183 0/imm32/no-imm32
28184 0/imm32/no-imm8
28185 0/imm32/no-disp32
28186 0/imm32/no-xm32
28187 0/imm32/no-x32
28188 0x11/imm32/alloc-id:fake
28189 _Primitive-increment-mem/imm32/next
28190 _Primitive-increment-mem:
28191 0x11/imm32/alloc-id:fake:payload
28192
28193 0x11/imm32/alloc-id:fake
28194 _string-increment/imm32/name
28195 0x11/imm32/alloc-id:fake
28196 Single-int-var-in-mem/imm32/inouts
28197 0/imm32/no-outputs
28198 0/imm32/no-outputs
28199 0x11/imm32/alloc-id:fake
28200 _string_ff_subop_increment/imm32/subx-name
28201 1/imm32/rm32-is-first-inout
28202 0/imm32/no-r32
28203 0/imm32/no-imm32
28204 0/imm32/no-imm8
28205 0/imm32/no-disp32
28206 0/imm32/no-xm32
28207 0/imm32/no-x32
28208 0x11/imm32/alloc-id:fake
28209 _Primitive-increment-reg/imm32/next
28210 _Primitive-increment-reg:
28211 0x11/imm32/alloc-id:fake:payload
28212
28213 0x11/imm32/alloc-id:fake
28214 _string-increment/imm32/name
28215 0/imm32/no-inouts
28216 0/imm32/no-inouts
28217 0x11/imm32/alloc-id:fake
28218 Single-int-var-in-some-register/imm32/outputs
28219 0x11/imm32/alloc-id:fake
28220 _string_ff_subop_increment/imm32/subx-name
28221 3/imm32/rm32-is-first-output
28222 0/imm32/no-r32
28223 0/imm32/no-imm32
28224 0/imm32/no-imm8
28225 0/imm32/no-disp32
28226 0/imm32/no-xm32
28227 0/imm32/no-x32
28228 0x11/imm32/alloc-id:fake
28229 _Primitive-decrement-mem/imm32/next
28230 _Primitive-decrement-mem:
28231 0x11/imm32/alloc-id:fake:payload
28232
28233 0x11/imm32/alloc-id:fake
28234 _string-decrement/imm32/name
28235 0x11/imm32/alloc-id:fake
28236 Single-int-var-in-mem/imm32/inouts
28237 0/imm32/no-outputs
28238 0/imm32/no-outputs
28239 0x11/imm32/alloc-id:fake
28240 _string_ff_subop_decrement/imm32/subx-name
28241 1/imm32/rm32-is-first-inout
28242 0/imm32/no-r32
28243 0/imm32/no-imm32
28244 0/imm32/no-imm8
28245 0/imm32/no-disp32
28246 0/imm32/no-xm32
28247 0/imm32/no-x32
28248 0x11/imm32/alloc-id:fake
28249 _Primitive-decrement-reg/imm32/next
28250 _Primitive-decrement-reg:
28251 0x11/imm32/alloc-id:fake:payload
28252
28253 0x11/imm32/alloc-id:fake
28254 _string-decrement/imm32/name
28255 0/imm32/no-inouts
28256 0/imm32/no-inouts
28257 0x11/imm32/alloc-id:fake
28258 Single-int-var-in-some-register/imm32/outputs
28259 0x11/imm32/alloc-id:fake
28260 _string_ff_subop_decrement/imm32/subx-name
28261 3/imm32/rm32-is-first-output
28262 0/imm32/no-r32
28263 0/imm32/no-imm32
28264 0/imm32/no-imm8
28265 0/imm32/no-disp32
28266 0/imm32/no-xm32
28267 0/imm32/no-x32
28268 0x11/imm32/alloc-id:fake
28269 _Primitive-add-to-eax/imm32/next
28270
28271 _Primitive-add-to-eax:
28272 0x11/imm32/alloc-id:fake:payload
28273
28274 0x11/imm32/alloc-id:fake
28275 _string-add/imm32/name
28276 0x11/imm32/alloc-id:fake
28277 Single-lit-var/imm32/inouts
28278 0x11/imm32/alloc-id:fake
28279 Single-int-var-in-eax/imm32/outputs
28280 0x11/imm32/alloc-id:fake
28281 _string_05_add_to_eax/imm32/subx-name
28282 0/imm32/no-rm32
28283 0/imm32/no-r32
28284 1/imm32/imm32-is-first-inout
28285 0/imm32/no-imm8
28286 0/imm32/no-disp32
28287 0/imm32/no-xm32
28288 0/imm32/no-x32
28289 0x11/imm32/alloc-id:fake
28290 _Primitive-add-reg-to-reg/imm32/next
28291 _Primitive-add-reg-to-reg:
28292 0x11/imm32/alloc-id:fake:payload
28293
28294 0x11/imm32/alloc-id:fake
28295 _string-add/imm32/name
28296 0x11/imm32/alloc-id:fake
28297 Single-int-var-in-some-register/imm32/inouts
28298 0x11/imm32/alloc-id:fake
28299 Single-int-var-in-some-register/imm32/outputs
28300 0x11/imm32/alloc-id:fake
28301 _string_01_add_to/imm32/subx-name
28302 3/imm32/rm32-is-first-output
28303 1/imm32/r32-is-first-inout
28304 0/imm32/no-imm32
28305 0/imm32/no-imm8
28306 0/imm32/no-disp32
28307 0/imm32/no-xm32
28308 0/imm32/no-x32
28309 0x11/imm32/alloc-id:fake
28310 _Primitive-add-reg-to-mem/imm32/next
28311 _Primitive-add-reg-to-mem:
28312 0x11/imm32/alloc-id:fake:payload
28313
28314 0x11/imm32/alloc-id:fake
28315 _string-add-to/imm32/name
28316 0x11/imm32/alloc-id:fake
28317 Two-args-int-stack-int-reg/imm32/inouts
28318 0/imm32/no-outputs
28319 0/imm32/no-outputs
28320 0x11/imm32/alloc-id:fake
28321 _string_01_add_to/imm32/subx-name
28322 1/imm32/rm32-is-first-inout
28323 2/imm32/r32-is-second-inout
28324 0/imm32/no-imm32
28325 0/imm32/no-imm8
28326 0/imm32/no-disp32
28327 0/imm32/no-xm32
28328 0/imm32/no-x32
28329 0x11/imm32/alloc-id:fake
28330 _Primitive-add-mem-to-reg/imm32/next
28331 _Primitive-add-mem-to-reg:
28332 0x11/imm32/alloc-id:fake:payload
28333
28334 0x11/imm32/alloc-id:fake
28335 _string-add/imm32/name
28336 0x11/imm32/alloc-id:fake
28337 Single-int-var-in-mem/imm32/inouts
28338 0x11/imm32/alloc-id:fake
28339 Single-int-var-in-some-register/imm32/outputs
28340 0x11/imm32/alloc-id:fake
28341 _string_03_add/imm32/subx-name
28342 1/imm32/rm32-is-first-inout
28343 3/imm32/r32-is-first-output
28344 0/imm32/no-imm32
28345 0/imm32/no-imm8
28346 0/imm32/no-disp32
28347 0/imm32/no-xm32
28348 0/imm32/no-x32
28349 0x11/imm32/alloc-id:fake
28350 _Primitive-add-lit-to-reg/imm32/next
28351 _Primitive-add-lit-to-reg:
28352 0x11/imm32/alloc-id:fake:payload
28353
28354 0x11/imm32/alloc-id:fake
28355 _string-add/imm32/name
28356 0x11/imm32/alloc-id:fake
28357 Single-lit-var/imm32/inouts
28358 0x11/imm32/alloc-id:fake
28359 Single-int-var-in-some-register/imm32/outputs
28360 0x11/imm32/alloc-id:fake
28361 _string_81_subop_add/imm32/subx-name
28362 3/imm32/rm32-is-first-output
28363 0/imm32/no-r32
28364 1/imm32/imm32-is-first-inout
28365 0/imm32/no-imm8
28366 0/imm32/no-disp32
28367 0/imm32/no-xm32
28368 0/imm32/no-x32
28369 0x11/imm32/alloc-id:fake
28370 _Primitive-add-lit-to-mem/imm32/next
28371 _Primitive-add-lit-to-mem:
28372 0x11/imm32/alloc-id:fake:payload
28373
28374 0x11/imm32/alloc-id:fake
28375 _string-add-to/imm32/name
28376 0x11/imm32/alloc-id:fake
28377 Int-var-and-literal/imm32/inouts
28378 0/imm32/no-outputs
28379 0/imm32/no-outputs
28380 0x11/imm32/alloc-id:fake
28381 _string_81_subop_add/imm32/subx-name
28382 1/imm32/rm32-is-first-inout
28383 0/imm32/no-r32
28384 2/imm32/imm32-is-second-inout
28385 0/imm32/no-imm8
28386 0/imm32/no-disp32
28387 0/imm32/no-xm32
28388 0/imm32/no-x32
28389 0x11/imm32/alloc-id:fake
28390 _Primitive-subtract-from-eax/imm32/next
28391
28392 _Primitive-subtract-from-eax:
28393 0x11/imm32/alloc-id:fake:payload
28394
28395 0x11/imm32/alloc-id:fake
28396 _string-subtract/imm32/name
28397 0x11/imm32/alloc-id:fake
28398 Single-lit-var/imm32/inouts
28399 0x11/imm32/alloc-id:fake
28400 Single-int-var-in-eax/imm32/outputs
28401 0x11/imm32/alloc-id:fake
28402 _string_2d_subtract_from_eax/imm32/subx-name
28403 0/imm32/no-rm32
28404 0/imm32/no-r32
28405 1/imm32/imm32-is-first-inout
28406 0/imm32/no-imm8
28407 0/imm32/no-disp32
28408 0/imm32/no-xm32
28409 0/imm32/no-x32
28410 0x11/imm32/alloc-id:fake
28411 _Primitive-subtract-reg-from-reg/imm32/next
28412 _Primitive-subtract-reg-from-reg:
28413 0x11/imm32/alloc-id:fake:payload
28414
28415 0x11/imm32/alloc-id:fake
28416 _string-subtract/imm32/name
28417 0x11/imm32/alloc-id:fake
28418 Single-int-var-in-some-register/imm32/inouts
28419 0x11/imm32/alloc-id:fake
28420 Single-int-var-in-some-register/imm32/outputs
28421 0x11/imm32/alloc-id:fake
28422 _string_29_subtract_from/imm32/subx-name
28423 3/imm32/rm32-is-first-output
28424 1/imm32/r32-is-first-inout
28425 0/imm32/no-imm32
28426 0/imm32/no-imm8
28427 0/imm32/no-disp32
28428 0/imm32/no-xm32
28429 0/imm32/no-x32
28430 0x11/imm32/alloc-id:fake
28431 _Primitive-subtract-reg-from-mem/imm32/next
28432 _Primitive-subtract-reg-from-mem:
28433 0x11/imm32/alloc-id:fake:payload
28434
28435 0x11/imm32/alloc-id:fake
28436 _string-subtract-from/imm32/name
28437 0x11/imm32/alloc-id:fake
28438 Two-args-int-stack-int-reg/imm32/inouts
28439 0/imm32/no-outputs
28440 0/imm32/no-outputs
28441 0x11/imm32/alloc-id:fake
28442 _string_29_subtract_from/imm32/subx-name
28443 1/imm32/rm32-is-first-inout
28444 2/imm32/r32-is-second-inout
28445 0/imm32/no-imm32
28446 0/imm32/no-imm8
28447 0/imm32/no-disp32
28448 0/imm32/no-xm32
28449 0/imm32/no-x32
28450 0x11/imm32/alloc-id:fake
28451 _Primitive-subtract-mem-from-reg/imm32/next
28452 _Primitive-subtract-mem-from-reg:
28453 0x11/imm32/alloc-id:fake:payload
28454
28455 0x11/imm32/alloc-id:fake
28456 _string-subtract/imm32/name
28457 0x11/imm32/alloc-id:fake
28458 Single-int-var-in-mem/imm32/inouts
28459 0x11/imm32/alloc-id:fake
28460 Single-int-var-in-some-register/imm32/outputs
28461 0x11/imm32/alloc-id:fake
28462 _string_2b_subtract/imm32/subx-name
28463 1/imm32/rm32-is-first-inout
28464 3/imm32/r32-is-first-output
28465 0/imm32/no-imm32
28466 0/imm32/no-imm8
28467 0/imm32/no-disp32
28468 0/imm32/no-xm32
28469 0/imm32/no-x32
28470 0x11/imm32/alloc-id:fake
28471 _Primitive-subtract-lit-from-reg/imm32/next
28472 _Primitive-subtract-lit-from-reg:
28473 0x11/imm32/alloc-id:fake:payload
28474
28475 0x11/imm32/alloc-id:fake
28476 _string-subtract/imm32/name
28477 0x11/imm32/alloc-id:fake
28478 Single-lit-var/imm32/inouts
28479 0x11/imm32/alloc-id:fake
28480 Single-int-var-in-some-register/imm32/outputs
28481 0x11/imm32/alloc-id:fake
28482 _string_81_subop_subtract/imm32/subx-name
28483 3/imm32/rm32-is-first-output
28484 0/imm32/no-r32
28485 1/imm32/imm32-is-first-inout
28486 0/imm32/no-imm8
28487 0/imm32/no-disp32
28488 0/imm32/no-xm32
28489 0/imm32/no-x32
28490 0x11/imm32/alloc-id:fake
28491 _Primitive-subtract-lit-from-mem/imm32/next
28492 _Primitive-subtract-lit-from-mem:
28493 0x11/imm32/alloc-id:fake:payload
28494
28495 0x11/imm32/alloc-id:fake
28496 _string-subtract-from/imm32/name
28497 0x11/imm32/alloc-id:fake
28498 Int-var-and-literal/imm32/inouts
28499 0/imm32/no-outputs
28500 0/imm32/no-outputs
28501 0x11/imm32/alloc-id:fake
28502 _string_81_subop_subtract/imm32/subx-name
28503 1/imm32/rm32-is-first-inout
28504 0/imm32/no-r32
28505 2/imm32/imm32-is-second-inout
28506 0/imm32/no-imm8
28507 0/imm32/no-disp32
28508 0/imm32/no-xm32
28509 0/imm32/no-x32
28510 0x11/imm32/alloc-id:fake
28511 _Primitive-and-with-eax/imm32/next
28512
28513 _Primitive-and-with-eax:
28514 0x11/imm32/alloc-id:fake:payload
28515
28516 0x11/imm32/alloc-id:fake
28517 _string-and/imm32/name
28518 0x11/imm32/alloc-id:fake
28519 Single-lit-var/imm32/inouts
28520 0x11/imm32/alloc-id:fake
28521 Single-int-var-in-eax/imm32/outputs
28522 0x11/imm32/alloc-id:fake
28523 _string_25_and_with_eax/imm32/subx-name
28524 0/imm32/no-rm32
28525 0/imm32/no-r32
28526 1/imm32/imm32-is-first-inout
28527 0/imm32/no-imm8
28528 0/imm32/no-disp32
28529 0/imm32/no-xm32
28530 0/imm32/no-x32
28531 0x11/imm32/alloc-id:fake
28532 _Primitive-and-reg-with-reg/imm32/next
28533 _Primitive-and-reg-with-reg:
28534 0x11/imm32/alloc-id:fake:payload
28535
28536 0x11/imm32/alloc-id:fake
28537 _string-and/imm32/name
28538 0x11/imm32/alloc-id:fake
28539 Single-int-var-in-some-register/imm32/inouts
28540 0x11/imm32/alloc-id:fake
28541 Single-int-var-in-some-register/imm32/outputs
28542 0x11/imm32/alloc-id:fake
28543 _string_21_and_with/imm32/subx-name
28544 3/imm32/rm32-is-first-output
28545 1/imm32/r32-is-first-inout
28546 0/imm32/no-imm32
28547 0/imm32/no-imm8
28548 0/imm32/no-disp32
28549 0/imm32/no-xm32
28550 0/imm32/no-x32
28551 0x11/imm32/alloc-id:fake
28552 _Primitive-and-reg-with-mem/imm32/next
28553 _Primitive-and-reg-with-mem:
28554 0x11/imm32/alloc-id:fake:payload
28555
28556 0x11/imm32/alloc-id:fake
28557 _string-and-with/imm32/name
28558 0x11/imm32/alloc-id:fake
28559 Two-args-int-stack-int-reg/imm32/inouts
28560 0/imm32/no-outputs
28561 0/imm32/no-outputs
28562 0x11/imm32/alloc-id:fake
28563 _string_21_and_with/imm32/subx-name
28564 1/imm32/rm32-is-first-inout
28565 2/imm32/r32-is-second-inout
28566 0/imm32/no-imm32
28567 0/imm32/no-imm8
28568 0/imm32/no-disp32
28569 0/imm32/no-xm32
28570 0/imm32/no-x32
28571 0x11/imm32/alloc-id:fake
28572 _Primitive-and-mem-with-reg/imm32/next
28573 _Primitive-and-mem-with-reg:
28574 0x11/imm32/alloc-id:fake:payload
28575
28576 0x11/imm32/alloc-id:fake
28577 _string-and/imm32/name
28578 0x11/imm32/alloc-id:fake
28579 Single-int-var-in-mem/imm32/inouts
28580 0x11/imm32/alloc-id:fake
28581 Single-int-var-in-some-register/imm32/outputs
28582 0x11/imm32/alloc-id:fake
28583 _string_23_and/imm32/subx-name
28584 1/imm32/rm32-is-first-inout
28585 3/imm32/r32-is-first-output
28586 0/imm32/no-imm32
28587 0/imm32/no-imm8
28588 0/imm32/no-disp32
28589 0/imm32/no-xm32
28590 0/imm32/no-x32
28591 0x11/imm32/alloc-id:fake
28592 _Primitive-and-lit-with-reg/imm32/next
28593 _Primitive-and-lit-with-reg:
28594 0x11/imm32/alloc-id:fake:payload
28595
28596 0x11/imm32/alloc-id:fake
28597 _string-and/imm32/name
28598 0x11/imm32/alloc-id:fake
28599 Single-lit-var/imm32/inouts
28600 0x11/imm32/alloc-id:fake
28601 Single-int-var-in-some-register/imm32/outputs
28602 0x11/imm32/alloc-id:fake
28603 _string_81_subop_and/imm32/subx-name
28604 3/imm32/rm32-is-first-output
28605 0/imm32/no-r32
28606 1/imm32/imm32-is-first-inout
28607 0/imm32/no-imm8
28608 0/imm32/no-disp32
28609 0/imm32/no-xm32
28610 0/imm32/no-x32
28611 0x11/imm32/alloc-id:fake
28612 _Primitive-and-lit-with-mem/imm32/next
28613 _Primitive-and-lit-with-mem:
28614 0x11/imm32/alloc-id:fake:payload
28615
28616 0x11/imm32/alloc-id:fake
28617 _string-and-with/imm32/name
28618 0x11/imm32/alloc-id:fake
28619 Int-var-and-literal/imm32/inouts
28620 0/imm32/no-outputs
28621 0/imm32/no-outputs
28622 0x11/imm32/alloc-id:fake
28623 _string_81_subop_and/imm32/subx-name
28624 1/imm32/rm32-is-first-inout
28625 0/imm32/no-r32
28626 2/imm32/imm32-is-second-inout
28627 0/imm32/no-imm8
28628 0/imm32/no-disp32
28629 0/imm32/no-xm32
28630 0/imm32/no-x32
28631 0x11/imm32/alloc-id:fake
28632 _Primitive-or-with-eax/imm32/next
28633
28634 _Primitive-or-with-eax:
28635 0x11/imm32/alloc-id:fake:payload
28636
28637 0x11/imm32/alloc-id:fake
28638 _string-or/imm32/name
28639 0x11/imm32/alloc-id:fake
28640 Single-lit-var/imm32/inouts
28641 0x11/imm32/alloc-id:fake
28642 Single-int-var-in-eax/imm32/outputs
28643 0x11/imm32/alloc-id:fake
28644 _string_0d_or_with_eax/imm32/subx-name
28645 0/imm32/no-rm32
28646 0/imm32/no-r32
28647 1/imm32/imm32-is-first-inout
28648 0/imm32/no-imm8
28649 0/imm32/no-disp32
28650 0/imm32/no-xm32
28651 0/imm32/no-x32
28652 0x11/imm32/alloc-id:fake
28653 _Primitive-or-reg-with-reg/imm32/next
28654 _Primitive-or-reg-with-reg:
28655 0x11/imm32/alloc-id:fake:payload
28656
28657 0x11/imm32/alloc-id:fake
28658 _string-or/imm32/name
28659 0x11/imm32/alloc-id:fake
28660 Single-int-var-in-some-register/imm32/inouts
28661 0x11/imm32/alloc-id:fake
28662 Single-int-var-in-some-register/imm32/outputs
28663 0x11/imm32/alloc-id:fake
28664 _string_09_or_with/imm32/subx-name
28665 3/imm32/rm32-is-first-output
28666 1/imm32/r32-is-first-inout
28667 0/imm32/no-imm32
28668 0/imm32/no-imm8
28669 0/imm32/no-disp32
28670 0/imm32/no-xm32
28671 0/imm32/no-x32
28672 0x11/imm32/alloc-id:fake
28673 _Primitive-or-reg-with-mem/imm32/next
28674 _Primitive-or-reg-with-mem:
28675 0x11/imm32/alloc-id:fake:payload
28676
28677 0x11/imm32/alloc-id:fake
28678 _string-or-with/imm32/name
28679 0x11/imm32/alloc-id:fake
28680 Two-args-int-stack-int-reg/imm32/inouts
28681 0/imm32/no-outputs
28682 0/imm32/no-outputs
28683 0x11/imm32/alloc-id:fake
28684 _string_09_or_with/imm32/subx-name
28685 1/imm32/rm32-is-first-inout
28686 2/imm32/r32-is-second-inout
28687 0/imm32/no-imm32
28688 0/imm32/no-imm8
28689 0/imm32/no-disp32
28690 0/imm32/no-xm32
28691 0/imm32/no-x32
28692 0x11/imm32/alloc-id:fake
28693 _Primitive-or-mem-with-reg/imm32/next
28694 _Primitive-or-mem-with-reg:
28695 0x11/imm32/alloc-id:fake:payload
28696
28697 0x11/imm32/alloc-id:fake
28698 _string-or/imm32/name
28699 0x11/imm32/alloc-id:fake
28700 Single-int-var-in-mem/imm32/inouts
28701 0x11/imm32/alloc-id:fake
28702 Single-int-var-in-some-register/imm32/outputs
28703 0x11/imm32/alloc-id:fake
28704 _string_0b_or/imm32/subx-name
28705 1/imm32/rm32-is-first-inout
28706 3/imm32/r32-is-first-output
28707 0/imm32/no-imm32
28708 0/imm32/no-imm8
28709 0/imm32/no-disp32
28710 0/imm32/no-xm32
28711 0/imm32/no-x32
28712 0x11/imm32/alloc-id:fake
28713 _Primitive-or-lit-with-reg/imm32/next
28714 _Primitive-or-lit-with-reg:
28715 0x11/imm32/alloc-id:fake:payload
28716
28717 0x11/imm32/alloc-id:fake
28718 _string-or/imm32/name
28719 0x11/imm32/alloc-id:fake
28720 Single-lit-var/imm32/inouts
28721 0x11/imm32/alloc-id:fake
28722 Single-int-var-in-some-register/imm32/outputs
28723 0x11/imm32/alloc-id:fake
28724 _string_81_subop_or/imm32/subx-name
28725 3/imm32/rm32-is-first-output
28726 0/imm32/no-r32
28727 1/imm32/imm32-is-first-inout
28728 0/imm32/no-imm8
28729 0/imm32/no-disp32
28730 0/imm32/no-xm32
28731 0/imm32/no-x32
28732 0x11/imm32/alloc-id:fake
28733 _Primitive-or-lit-with-mem/imm32/next
28734 _Primitive-or-lit-with-mem:
28735 0x11/imm32/alloc-id:fake:payload
28736
28737 0x11/imm32/alloc-id:fake
28738 _string-or-with/imm32/name
28739 0x11/imm32/alloc-id:fake
28740 Int-var-and-literal/imm32/inouts
28741 0/imm32/no-outputs
28742 0/imm32/no-outputs
28743 0x11/imm32/alloc-id:fake
28744 _string_81_subop_or/imm32/subx-name
28745 1/imm32/rm32-is-first-inout
28746 0/imm32/no-r32
28747 2/imm32/imm32-is-second-inout
28748 0/imm32/no-imm8
28749 0/imm32/no-disp32
28750 0/imm32/no-xm32
28751 0/imm32/no-x32
28752 0x11/imm32/alloc-id:fake
28753 _Primitive-xor-with-eax/imm32/next
28754
28755 _Primitive-xor-with-eax:
28756 0x11/imm32/alloc-id:fake:payload
28757
28758 0x11/imm32/alloc-id:fake
28759 _string-xor/imm32/name
28760 0x11/imm32/alloc-id:fake
28761 Single-lit-var/imm32/inouts
28762 0x11/imm32/alloc-id:fake
28763 Single-int-var-in-eax/imm32/outputs
28764 0x11/imm32/alloc-id:fake
28765 _string_35_xor_with_eax/imm32/subx-name
28766 0/imm32/no-rm32
28767 0/imm32/no-r32
28768 1/imm32/imm32-is-first-inout
28769 0/imm32/no-imm8
28770 0/imm32/no-disp32
28771 0/imm32/no-xm32
28772 0/imm32/no-x32
28773 0x11/imm32/alloc-id:fake
28774 _Primitive-xor-reg-with-reg/imm32/next
28775 _Primitive-xor-reg-with-reg:
28776 0x11/imm32/alloc-id:fake:payload
28777
28778 0x11/imm32/alloc-id:fake
28779 _string-xor/imm32/name
28780 0x11/imm32/alloc-id:fake
28781 Single-int-var-in-some-register/imm32/inouts
28782 0x11/imm32/alloc-id:fake
28783 Single-int-var-in-some-register/imm32/outputs
28784 0x11/imm32/alloc-id:fake
28785 _string_31_xor_with/imm32/subx-name
28786 3/imm32/rm32-is-first-output
28787 1/imm32/r32-is-first-inout
28788 0/imm32/no-imm32
28789 0/imm32/no-imm8
28790 0/imm32/no-disp32
28791 0/imm32/no-xm32
28792 0/imm32/no-x32
28793 0x11/imm32/alloc-id:fake
28794 _Primitive-xor-reg-with-mem/imm32/next
28795 _Primitive-xor-reg-with-mem:
28796 0x11/imm32/alloc-id:fake:payload
28797
28798 0x11/imm32/alloc-id:fake
28799 _string-xor-with/imm32/name
28800 0x11/imm32/alloc-id:fake
28801 Two-args-int-stack-int-reg/imm32/inouts
28802 0/imm32/no-outputs
28803 0/imm32/no-outputs
28804 0x11/imm32/alloc-id:fake
28805 _string_31_xor_with/imm32/subx-name
28806 1/imm32/rm32-is-first-inout
28807 2/imm32/r32-is-second-inout
28808 0/imm32/no-imm32
28809 0/imm32/no-imm8
28810 0/imm32/no-disp32
28811 0/imm32/no-xm32
28812 0/imm32/no-x32
28813 0x11/imm32/alloc-id:fake
28814 _Primitive-xor-mem-with-reg/imm32/next
28815 _Primitive-xor-mem-with-reg:
28816 0x11/imm32/alloc-id:fake:payload
28817
28818 0x11/imm32/alloc-id:fake
28819 _string-xor/imm32/name
28820 0x11/imm32/alloc-id:fake
28821 Single-int-var-in-mem/imm32/inouts
28822 0x11/imm32/alloc-id:fake
28823 Single-int-var-in-some-register/imm32/outputs
28824 0x11/imm32/alloc-id:fake
28825 _string_33_xor/imm32/subx-name
28826 1/imm32/rm32-is-first-inout
28827 3/imm32/r32-is-first-output
28828 0/imm32/no-imm32
28829 0/imm32/no-imm8
28830 0/imm32/no-disp32
28831 0/imm32/no-xm32
28832 0/imm32/no-x32
28833 0x11/imm32/alloc-id:fake
28834 _Primitive-xor-lit-with-reg/imm32/next
28835 _Primitive-xor-lit-with-reg:
28836 0x11/imm32/alloc-id:fake:payload
28837
28838 0x11/imm32/alloc-id:fake
28839 _string-xor/imm32/name
28840 0x11/imm32/alloc-id:fake
28841 Single-lit-var/imm32/inouts
28842 0x11/imm32/alloc-id:fake
28843 Single-int-var-in-some-register/imm32/outputs
28844 0x11/imm32/alloc-id:fake
28845 _string_81_subop_xor/imm32/subx-name
28846 3/imm32/rm32-is-first-output
28847 0/imm32/no-r32
28848 1/imm32/imm32-is-first-inout
28849 0/imm32/no-imm8
28850 0/imm32/no-disp32
28851 0/imm32/no-xm32
28852 0/imm32/no-x32
28853 0x11/imm32/alloc-id:fake
28854 _Primitive-xor-lit-with-mem/imm32/next
28855 _Primitive-xor-lit-with-mem:
28856 0x11/imm32/alloc-id:fake:payload
28857
28858 0x11/imm32/alloc-id:fake
28859 _string-xor-with/imm32/name
28860 0x11/imm32/alloc-id:fake
28861 Int-var-and-literal/imm32/inouts
28862 0/imm32/no-outputs
28863 0/imm32/no-outputs
28864 0x11/imm32/alloc-id:fake
28865 _string_81_subop_xor/imm32/subx-name
28866 1/imm32/rm32-is-first-inout
28867 0/imm32/no-r32
28868 2/imm32/imm32-is-second-inout
28869 0/imm32/no-imm8
28870 0/imm32/no-disp32
28871 0/imm32/no-xm32
28872 0/imm32/no-x32
28873 0x11/imm32/alloc-id:fake
28874 _Primitive-shift-reg-left-by-lit/imm32/next
28875 _Primitive-shift-reg-left-by-lit:
28876 0x11/imm32/alloc-id:fake:payload
28877
28878 0x11/imm32/alloc-id:fake
28879 _string-shift-left/imm32/name
28880 0x11/imm32/alloc-id:fake
28881 Single-lit-var/imm32/inouts
28882 0x11/imm32/alloc-id:fake
28883 Single-int-var-in-some-register/imm32/outputs
28884 0x11/imm32/alloc-id:fake
28885 _string_c1_subop_shift_left/imm32/subx-name
28886 3/imm32/rm32-is-first-output
28887 0/imm32/no-r32
28888 0/imm32/no-imm32
28889 1/imm32/imm8-is-first-inout
28890 0/imm32/no-disp32
28891 0/imm32/no-xm32
28892 0/imm32/no-x32
28893 0x11/imm32/alloc-id:fake
28894 _Primitive-shift-reg-right-by-lit/imm32/next
28895 _Primitive-shift-reg-right-by-lit:
28896 0x11/imm32/alloc-id:fake:payload
28897
28898 0x11/imm32/alloc-id:fake
28899 _string-shift-right/imm32/name
28900 0x11/imm32/alloc-id:fake
28901 Single-lit-var/imm32/inouts
28902 0x11/imm32/alloc-id:fake
28903 Single-int-var-in-some-register/imm32/outputs
28904 0x11/imm32/alloc-id:fake
28905 _string_c1_subop_shift_right_padding_zeroes/imm32/subx-name
28906 3/imm32/rm32-is-first-output
28907 0/imm32/no-r32
28908 0/imm32/no-imm32
28909 1/imm32/imm8-is-first-inout
28910 0/imm32/no-disp32
28911 0/imm32/no-xm32
28912 0/imm32/no-x32
28913 0x11/imm32/alloc-id:fake
28914 _Primitive-shift-reg-right-signed-by-lit/imm32/next
28915 _Primitive-shift-reg-right-signed-by-lit:
28916 0x11/imm32/alloc-id:fake:payload
28917
28918 0x11/imm32/alloc-id:fake
28919 _string-shift-right-signed/imm32/name
28920 0x11/imm32/alloc-id:fake
28921 Single-lit-var/imm32/inouts
28922 0x11/imm32/alloc-id:fake
28923 Single-int-var-in-some-register/imm32/outputs
28924 0x11/imm32/alloc-id:fake
28925 _string_c1_subop_shift_right_preserving_sign/imm32/subx-name
28926 3/imm32/rm32-is-first-output
28927 0/imm32/no-r32
28928 0/imm32/no-imm32
28929 1/imm32/imm8-is-first-inout
28930 0/imm32/no-disp32
28931 0/imm32/no-xm32
28932 0/imm32/no-x32
28933 0x11/imm32/alloc-id:fake
28934 _Primitive-shift-mem-left-by-lit/imm32/next
28935 _Primitive-shift-mem-left-by-lit:
28936 0x11/imm32/alloc-id:fake:payload
28937
28938 0x11/imm32/alloc-id:fake
28939 _string-shift-left/imm32/name
28940 0x11/imm32/alloc-id:fake
28941 Int-var-and-literal/imm32/inouts
28942 0/imm32/no-outputs
28943 0/imm32/no-outputs
28944 0x11/imm32/alloc-id:fake
28945 _string_c1_subop_shift_left/imm32/subx-name
28946 1/imm32/rm32-is-first-inout
28947 0/imm32/no-r32
28948 0/imm32/no-imm32
28949 2/imm32/imm8-is-second-inout
28950 0/imm32/no-disp32
28951 0/imm32/no-xm32
28952 0/imm32/no-x32
28953 0x11/imm32/alloc-id:fake
28954 _Primitive-shift-mem-right-by-lit/imm32/next
28955 _Primitive-shift-mem-right-by-lit:
28956 0x11/imm32/alloc-id:fake:payload
28957
28958 0x11/imm32/alloc-id:fake
28959 _string-shift-right/imm32/name
28960 0x11/imm32/alloc-id:fake
28961 Int-var-and-literal/imm32/inouts
28962 0/imm32/no-outputs
28963 0/imm32/no-outputs
28964 0x11/imm32/alloc-id:fake
28965 _string_c1_subop_shift_right_padding_zeroes/imm32/subx-name
28966 1/imm32/rm32-is-first-inout
28967 0/imm32/no-r32
28968 0/imm32/no-imm32
28969 2/imm32/imm8-is-second-inout
28970 0/imm32/no-disp32
28971 0/imm32/no-xm32
28972 0/imm32/no-x32
28973 0x11/imm32/alloc-id:fake
28974 _Primitive-shift-mem-right-signed-by-lit/imm32/next
28975 _Primitive-shift-mem-right-signed-by-lit:
28976 0x11/imm32/alloc-id:fake:payload
28977
28978 0x11/imm32/alloc-id:fake
28979 _string-shift-right-signed/imm32/name
28980 0x11/imm32/alloc-id:fake
28981 Int-var-and-literal/imm32/inouts
28982 0/imm32/no-outputs
28983 0/imm32/no-outputs
28984 0x11/imm32/alloc-id:fake
28985 _string_c1_subop_shift_right_preserving_sign/imm32/subx-name
28986 1/imm32/rm32-is-first-inout
28987 0/imm32/no-r32
28988 0/imm32/no-imm32
28989 2/imm32/imm8-is-second-inout
28990 0/imm32/no-disp32
28991 0/imm32/no-xm32
28992 0/imm32/no-x32
28993 0x11/imm32/alloc-id:fake
28994 _Primitive-copy-to-eax/imm32/next
28995
28996 _Primitive-copy-to-eax:
28997 0x11/imm32/alloc-id:fake:payload
28998
28999 0x11/imm32/alloc-id:fake
29000 _string-copy/imm32/name
29001 0x11/imm32/alloc-id:fake
29002 Single-lit-var/imm32/inouts
29003 0x11/imm32/alloc-id:fake
29004 Single-int-var-in-eax/imm32/outputs
29005 0x11/imm32/alloc-id:fake
29006 _string_b8_copy_to_eax/imm32/subx-name
29007 0/imm32/no-rm32
29008 0/imm32/no-r32
29009 1/imm32/imm32-is-first-inout
29010 0/imm32/no-imm8
29011 0/imm32/no-disp32
29012 0/imm32/no-xm32
29013 0/imm32/no-x32
29014 0x11/imm32/alloc-id:fake
29015 _Primitive-copy-to-ecx/imm32/next
29016 _Primitive-copy-to-ecx:
29017 0x11/imm32/alloc-id:fake:payload
29018
29019 0x11/imm32/alloc-id:fake
29020 _string-copy/imm32/name
29021 0x11/imm32/alloc-id:fake
29022 Single-lit-var/imm32/inouts
29023 0x11/imm32/alloc-id:fake
29024 Single-int-var-in-ecx/imm32/outputs
29025 0x11/imm32/alloc-id:fake
29026 _string_b9_copy_to_ecx/imm32/subx-name
29027 0/imm32/no-rm32
29028 0/imm32/no-r32
29029 1/imm32/imm32-is-first-inout
29030 0/imm32/no-imm8
29031 0/imm32/no-disp32
29032 0/imm32/no-xm32
29033 0/imm32/no-x32
29034 0x11/imm32/alloc-id:fake
29035 _Primitive-copy-to-edx/imm32/next
29036 _Primitive-copy-to-edx:
29037 0x11/imm32/alloc-id:fake:payload
29038
29039 0x11/imm32/alloc-id:fake
29040 _string-copy/imm32/name
29041 0x11/imm32/alloc-id:fake
29042 Single-lit-var/imm32/inouts
29043 0x11/imm32/alloc-id:fake
29044 Single-int-var-in-edx/imm32/outputs
29045 0x11/imm32/alloc-id:fake
29046 _string_ba_copy_to_edx/imm32/subx-name
29047 0/imm32/no-rm32
29048 0/imm32/no-r32
29049 1/imm32/imm32-is-first-inout
29050 0/imm32/no-imm8
29051 0/imm32/no-disp32
29052 0/imm32/no-xm32
29053 0/imm32/no-x32
29054 0x11/imm32/alloc-id:fake
29055 _Primitive-copy-to-ebx/imm32/next
29056 _Primitive-copy-to-ebx:
29057 0x11/imm32/alloc-id:fake:payload
29058
29059 0x11/imm32/alloc-id:fake
29060 _string-copy/imm32/name
29061 0x11/imm32/alloc-id:fake
29062 Single-lit-var/imm32/inouts
29063 0x11/imm32/alloc-id:fake
29064 Single-int-var-in-ebx/imm32/outputs
29065 0x11/imm32/alloc-id:fake
29066 _string_bb_copy_to_ebx/imm32/subx-name
29067 0/imm32/no-rm32
29068 0/imm32/no-r32
29069 1/imm32/imm32-is-first-inout
29070 0/imm32/no-imm8
29071 0/imm32/no-disp32
29072 0/imm32/no-xm32
29073 0/imm32/no-x32
29074 0x11/imm32/alloc-id:fake
29075 _Primitive-copy-to-esi/imm32/next
29076 _Primitive-copy-to-esi:
29077 0x11/imm32/alloc-id:fake:payload
29078
29079 0x11/imm32/alloc-id:fake
29080 _string-copy/imm32/name
29081 0x11/imm32/alloc-id:fake
29082 Single-lit-var/imm32/inouts
29083 0x11/imm32/alloc-id:fake
29084 Single-int-var-in-esi/imm32/outputs
29085 0x11/imm32/alloc-id:fake
29086 _string_be_copy_to_esi/imm32/subx-name
29087 0/imm32/no-rm32
29088 0/imm32/no-r32
29089 1/imm32/imm32-is-first-inout
29090 0/imm32/no-imm8
29091 0/imm32/no-disp32
29092 0/imm32/no-xm32
29093 0/imm32/no-x32
29094 0x11/imm32/alloc-id:fake
29095 _Primitive-copy-to-edi/imm32/next
29096 _Primitive-copy-to-edi:
29097 0x11/imm32/alloc-id:fake:payload
29098
29099 0x11/imm32/alloc-id:fake
29100 _string-copy/imm32/name
29101 0x11/imm32/alloc-id:fake
29102 Single-lit-var/imm32/inouts
29103 0x11/imm32/alloc-id:fake
29104 Single-int-var-in-edi/imm32/outputs
29105 0x11/imm32/alloc-id:fake
29106 _string_bf_copy_to_edi/imm32/subx-name
29107 0/imm32/no-rm32
29108 0/imm32/no-r32
29109 1/imm32/imm32-is-first-inout
29110 0/imm32/no-imm8
29111 0/imm32/no-disp32
29112 0/imm32/no-xm32
29113 0/imm32/no-x32
29114 0x11/imm32/alloc-id:fake
29115 _Primitive-copy-reg-to-reg/imm32/next
29116 _Primitive-copy-reg-to-reg:
29117 0x11/imm32/alloc-id:fake:payload
29118
29119 0x11/imm32/alloc-id:fake
29120 _string-copy/imm32/name
29121 0x11/imm32/alloc-id:fake
29122 Single-int-var-in-some-register/imm32/inouts
29123 0x11/imm32/alloc-id:fake
29124 Single-int-var-in-some-register/imm32/outputs
29125 0x11/imm32/alloc-id:fake
29126 _string_89_<-/imm32/subx-name
29127 3/imm32/rm32-is-first-output
29128 1/imm32/r32-is-first-inout
29129 0/imm32/no-imm32
29130 0/imm32/no-imm8
29131 0/imm32/no-disp32
29132 0/imm32/no-xm32
29133 0/imm32/no-x32
29134 0x11/imm32/alloc-id:fake
29135 _Primitive-copy-reg-to-mem/imm32/next
29136 _Primitive-copy-reg-to-mem:
29137 0x11/imm32/alloc-id:fake:payload
29138
29139 0x11/imm32/alloc-id:fake
29140 _string-copy-to/imm32/name
29141 0x11/imm32/alloc-id:fake
29142 Two-args-int-stack-int-reg/imm32/inouts
29143 0/imm32/no-outputs
29144 0/imm32/no-outputs
29145 0x11/imm32/alloc-id:fake
29146 _string_89_<-/imm32/subx-name
29147 1/imm32/rm32-is-first-inout
29148 2/imm32/r32-is-second-inout
29149 0/imm32/no-imm32
29150 0/imm32/no-imm8
29151 0/imm32/no-disp32
29152 0/imm32/no-xm32
29153 0/imm32/no-x32
29154 0x11/imm32/alloc-id:fake
29155 _Primitive-copy-mem-to-reg/imm32/next
29156 _Primitive-copy-mem-to-reg:
29157 0x11/imm32/alloc-id:fake:payload
29158
29159 0x11/imm32/alloc-id:fake
29160 _string-copy/imm32/name
29161 0x11/imm32/alloc-id:fake
29162 Single-int-var-in-mem/imm32/inouts
29163 0x11/imm32/alloc-id:fake
29164 Single-int-var-in-some-register/imm32/outputs
29165 0x11/imm32/alloc-id:fake
29166 _string_8b_->/imm32/subx-name
29167 1/imm32/rm32-is-first-inout
29168 3/imm32/r32-is-first-output
29169 0/imm32/no-imm32
29170 0/imm32/no-imm8
29171 0/imm32/no-disp32
29172 0/imm32/no-xm32
29173 0/imm32/no-x32
29174 0x11/imm32/alloc-id:fake
29175 _Primitive-copy-lit-to-reg/imm32/next
29176 _Primitive-copy-lit-to-reg:
29177 0x11/imm32/alloc-id:fake:payload
29178
29179 0x11/imm32/alloc-id:fake
29180 _string-copy/imm32/name
29181 0x11/imm32/alloc-id:fake
29182 Single-lit-var/imm32/inouts
29183 0x11/imm32/alloc-id:fake
29184 Single-int-var-in-some-register/imm32/outputs
29185 0x11/imm32/alloc-id:fake
29186 _string_c7_subop_copy/imm32/subx-name
29187 3/imm32/rm32-is-first-output
29188 0/imm32/no-r32
29189 1/imm32/imm32-is-first-inout
29190 0/imm32/no-imm8
29191 0/imm32/no-disp32
29192 0/imm32/no-xm32
29193 0/imm32/no-x32
29194 0x11/imm32/alloc-id:fake
29195 _Primitive-copy-lit-to-mem/imm32/next
29196 _Primitive-copy-lit-to-mem:
29197 0x11/imm32/alloc-id:fake:payload
29198
29199 0x11/imm32/alloc-id:fake
29200 _string-copy-to/imm32/name
29201 0x11/imm32/alloc-id:fake
29202 Int-var-and-literal/imm32/inouts
29203 0/imm32/no-outputs
29204 0/imm32/no-outputs
29205 0x11/imm32/alloc-id:fake
29206 _string_c7_subop_copy/imm32/subx-name
29207 1/imm32/rm32-is-first-inout
29208 0/imm32/no-r32
29209 2/imm32/imm32-is-second-inout
29210 0/imm32/no-imm8
29211 0/imm32/no-disp32
29212 0/imm32/no-xm32
29213 0/imm32/no-x32
29214 0x11/imm32/alloc-id:fake
29215 _Primitive-copy-byte-from-reg/imm32/next
29216
29217 _Primitive-copy-byte-from-reg:
29218 0x11/imm32/alloc-id:fake:payload
29219
29220 0x11/imm32/alloc-id:fake
29221 _string-copy-byte/imm32/name
29222 0x11/imm32/alloc-id:fake
29223 Single-byte-var-in-some-register/imm32/inouts
29224 0x11/imm32/alloc-id:fake
29225 Single-byte-var-in-some-register/imm32/outputs
29226 0x11/imm32/alloc-id:fake
29227 _string_8a_copy_byte/imm32/subx-name
29228 1/imm32/rm32-is-first-inout
29229 3/imm32/r32-is-first-output
29230 0/imm32/no-imm32
29231 0/imm32/no-imm8
29232 0/imm32/no-disp32
29233 0/imm32/no-xm32
29234 0/imm32/no-x32
29235 0x11/imm32/alloc-id:fake
29236 _Primitive-copy-byte-from-mem/imm32/next
29237 _Primitive-copy-byte-from-mem:
29238 0x11/imm32/alloc-id:fake:payload
29239
29240 0x11/imm32/alloc-id:fake
29241 _string-copy-byte/imm32/name
29242 0x11/imm32/alloc-id:fake
29243 Single-byte-var-in-mem/imm32/inouts
29244 0x11/imm32/alloc-id:fake
29245 Single-byte-var-in-some-register/imm32/outputs
29246 0x11/imm32/alloc-id:fake
29247 _string_8a_copy_byte/imm32/subx-name
29248 1/imm32/rm32-is-first-inout
29249 3/imm32/r32-is-first-output
29250 0/imm32/no-imm32
29251 0/imm32/no-imm8
29252 0/imm32/no-disp32
29253 0/imm32/no-xm32
29254 0/imm32/no-x32
29255 0x11/imm32/alloc-id:fake
29256 _Primitive-copy-byte-to-mem/imm32/next
29257 _Primitive-copy-byte-to-mem:
29258 0x11/imm32/alloc-id:fake:payload
29259
29260 0x11/imm32/alloc-id:fake
29261 _string-copy-byte-to/imm32/name
29262 0x11/imm32/alloc-id:fake
29263 Two-args-byte-stack-byte-reg/imm32/inouts
29264 0/imm32/no-outputs
29265 0/imm32/no-outputs
29266 0x11/imm32/alloc-id:fake
29267 _string_88_copy_byte/imm32/subx-name
29268 1/imm32/rm32-is-first-inout
29269 2/imm32/r32-is-second-inout
29270 0/imm32/no-imm32
29271 0/imm32/no-imm8
29272 0/imm32/no-disp32
29273 0/imm32/no-xm32
29274 0/imm32/no-x32
29275 0x11/imm32/alloc-id:fake
29276 _Primitive-address/imm32/next
29277
29278 _Primitive-address:
29279 0x11/imm32/alloc-id:fake:payload
29280
29281 0x11/imm32/alloc-id:fake
29282 _string-address/imm32/name
29283 0x11/imm32/alloc-id:fake
29284 Single-int-var-in-mem/imm32/inouts
29285 0x11/imm32/alloc-id:fake
29286 Single-addr-var-in-some-register/imm32/outputs
29287 0x11/imm32/alloc-id:fake
29288 _string_8d_copy_address/imm32/subx-name
29289 1/imm32/rm32-is-first-inout
29290 3/imm32/r32-is-first-output
29291 0/imm32/no-imm32
29292 0/imm32/no-imm8
29293 0/imm32/no-disp32
29294 0/imm32/no-xm32
29295 0/imm32/no-x32
29296 0x11/imm32/alloc-id:fake
29297 _Primitive-compare-reg-with-reg/imm32/next
29298
29299 _Primitive-compare-reg-with-reg:
29300 0x11/imm32/alloc-id:fake:payload
29301
29302 0x11/imm32/alloc-id:fake
29303 _string-compare/imm32/name
29304 0x11/imm32/alloc-id:fake
29305 Two-int-args-in-regs/imm32/inouts
29306 0/imm32/no-outputs
29307 0/imm32/no-outputs
29308 0x11/imm32/alloc-id:fake
29309 _string_39_compare->/imm32/subx-name
29310 1/imm32/rm32-is-first-inout
29311 2/imm32/r32-is-second-inout
29312 0/imm32/no-imm32
29313 0/imm32/no-imm8
29314 0/imm32/no-disp32
29315 0/imm32/no-xm32
29316 0/imm32/no-x32
29317 0x11/imm32/alloc-id:fake
29318 _Primitive-compare-mem-with-reg/imm32/next
29319 _Primitive-compare-mem-with-reg:
29320 0x11/imm32/alloc-id:fake:payload
29321
29322 0x11/imm32/alloc-id:fake
29323 _string-compare/imm32/name
29324 0x11/imm32/alloc-id:fake
29325 Two-args-int-stack-int-reg/imm32/inouts
29326 0/imm32/no-outputs
29327 0/imm32/no-outputs
29328 0x11/imm32/alloc-id:fake
29329 _string_39_compare->/imm32/subx-name
29330 1/imm32/rm32-is-first-inout
29331 2/imm32/r32-is-second-inout
29332 0/imm32/no-imm32
29333 0/imm32/no-imm8
29334 0/imm32/no-disp32
29335 0/imm32/no-xm32
29336 0/imm32/no-x32
29337 0x11/imm32/alloc-id:fake
29338 _Primitive-compare-reg-with-mem/imm32/next
29339 _Primitive-compare-reg-with-mem:
29340 0x11/imm32/alloc-id:fake:payload
29341
29342 0x11/imm32/alloc-id:fake
29343 _string-compare/imm32/name
29344 0x11/imm32/alloc-id:fake
29345 Two-args-int-reg-int-stack/imm32/inouts
29346 0/imm32/no-outputs
29347 0/imm32/no-outputs
29348 0x11/imm32/alloc-id:fake
29349 _string_3b_compare<-/imm32/subx-name
29350 2/imm32/rm32-is-second-inout
29351 1/imm32/r32-is-first-inout
29352 0/imm32/no-imm32
29353 0/imm32/no-imm8
29354 0/imm32/no-disp32
29355 0/imm32/no-xm32
29356 0/imm32/no-x32
29357 0x11/imm32/alloc-id:fake
29358 _Primitive-compare-eax-with-literal/imm32/next
29359 _Primitive-compare-eax-with-literal:
29360 0x11/imm32/alloc-id:fake:payload
29361
29362 0x11/imm32/alloc-id:fake
29363 _string-compare/imm32/name
29364 0x11/imm32/alloc-id:fake
29365 Two-args-int-eax-int-literal/imm32/inouts
29366 0/imm32/no-outputs
29367 0/imm32/no-outputs
29368 0x11/imm32/alloc-id:fake
29369 _string_3d_compare_eax_with/imm32/subx-name
29370 0/imm32/no-rm32
29371 0/imm32/no-r32
29372 2/imm32/imm32-is-second-inout
29373 0/imm32/no-imm8
29374 0/imm32/no-disp32
29375 0/imm32/no-xm32
29376 0/imm32/no-x32
29377 0x11/imm32/alloc-id:fake
29378 _Primitive-compare-reg-with-literal/imm32/next
29379 _Primitive-compare-reg-with-literal:
29380 0x11/imm32/alloc-id:fake:payload
29381
29382 0x11/imm32/alloc-id:fake
29383 _string-compare/imm32/name
29384 0x11/imm32/alloc-id:fake
29385 Int-var-in-register-and-literal/imm32/inouts
29386 0/imm32/no-outputs
29387 0/imm32/no-outputs
29388 0x11/imm32/alloc-id:fake
29389 _string_81_subop_compare/imm32/subx-name
29390 1/imm32/rm32-is-first-inout
29391 0/imm32/no-r32
29392 2/imm32/imm32-is-second-inout
29393 0/imm32/no-imm8
29394 0/imm32/no-disp32
29395 0/imm32/no-xm32
29396 0/imm32/no-x32
29397 0x11/imm32/alloc-id:fake
29398 _Primitive-compare-mem-with-literal/imm32/next
29399 _Primitive-compare-mem-with-literal:
29400 0x11/imm32/alloc-id:fake:payload
29401
29402 0x11/imm32/alloc-id:fake
29403 _string-compare/imm32/name
29404 0x11/imm32/alloc-id:fake
29405 Int-var-and-literal/imm32/inouts
29406 0/imm32/no-outputs
29407 0/imm32/no-outputs
29408 0x11/imm32/alloc-id:fake
29409 _string_81_subop_compare/imm32/subx-name
29410 1/imm32/rm32-is-first-inout
29411 0/imm32/no-r32
29412 2/imm32/imm32-is-second-inout
29413 0/imm32/no-imm8
29414 0/imm32/no-disp32
29415 0/imm32/no-xm32
29416 0/imm32/no-x32
29417 0x11/imm32/alloc-id:fake
29418 _Primitive-negate-reg/imm32/next
29419
29420 _Primitive-negate-reg:
29421 0x11/imm32/alloc-id:fake:payload
29422
29423 0x11/imm32/alloc-id:fake
29424 _string-negate/imm32/name
29425 0/imm32/no-inouts
29426 0/imm32/no-inouts
29427 0x11/imm32/alloc-id:fake
29428 Single-int-var-in-some-register/imm32/outputs
29429 0x11/imm32/alloc-id:fake
29430 _string_f7_subop_negate/imm32/subx-name
29431 3/imm32/rm32-is-first-output
29432 0/imm32/no-r32
29433 0/imm32/no-imm32
29434 0/imm32/no-imm8
29435 0/imm32/no-disp32
29436 0/imm32/no-xm32
29437 0/imm32/no-x32
29438 0x11/imm32/alloc-id:fake
29439 _Primitive-negate-mem/imm32/next
29440 _Primitive-negate-mem:
29441 0x11/imm32/alloc-id:fake:payload
29442
29443 0x11/imm32/alloc-id:fake
29444 _string-negate/imm32/name
29445 0x11/imm32/alloc-id:fake
29446 Single-int-var-in-mem/imm32/inouts
29447 0/imm32/no-outputs
29448 0/imm32/no-outputs
29449 0x11/imm32/alloc-id:fake
29450 _string_f7_subop_negate/imm32/subx-name
29451 1/imm32/rm32-is-first-inout
29452 0/imm32/no-r32
29453 0/imm32/no-imm32
29454 0/imm32/no-imm8
29455 0/imm32/no-disp32
29456 0/imm32/no-xm32
29457 0/imm32/no-x32
29458 0x11/imm32/alloc-id:fake
29459 _Primitive-multiply-reg-by-reg/imm32/next
29460
29461 _Primitive-multiply-reg-by-reg:
29462 0x11/imm32/alloc-id:fake:payload
29463
29464 0x11/imm32/alloc-id:fake
29465 _string-multiply/imm32/name
29466 0x11/imm32/alloc-id:fake
29467 Single-int-var-in-some-register/imm32/inouts
29468 0x11/imm32/alloc-id:fake
29469 Single-int-var-in-some-register/imm32/outputs
29470 0x11/imm32/alloc-id:fake
29471 _string_0f_af_multiply/imm32/subx-name
29472 1/imm32/rm32-is-first-inout
29473 3/imm32/r32-is-first-output
29474 0/imm32/no-imm32
29475 0/imm32/no-imm8
29476 0/imm32/no-disp32
29477 0/imm32/no-xm32
29478 0/imm32/no-x32
29479 0x11/imm32/alloc-id:fake
29480 _Primitive-multiply-reg-by-mem/imm32/next
29481 _Primitive-multiply-reg-by-mem:
29482 0x11/imm32/alloc-id:fake:payload
29483
29484 0x11/imm32/alloc-id:fake
29485 _string-multiply/imm32/name
29486 0x11/imm32/alloc-id:fake
29487 Single-int-var-in-mem/imm32/inouts
29488 0x11/imm32/alloc-id:fake
29489 Single-int-var-in-some-register/imm32/outputs
29490 0x11/imm32/alloc-id:fake
29491 _string_0f_af_multiply/imm32/subx-name
29492 1/imm32/rm32-is-first-inout
29493 3/imm32/r32-is-first-output
29494 0/imm32/no-imm32
29495 0/imm32/no-imm8
29496 0/imm32/no-disp32
29497 0/imm32/no-xm32
29498 0/imm32/no-x32
29499 0x11/imm32/alloc-id:fake
29500 _Primitive-convert-mem-to-xreg/imm32/next
29501
29502 _Primitive-convert-mem-to-xreg:
29503 0x11/imm32/alloc-id:fake:payload
29504
29505 0x11/imm32/alloc-id:fake
29506 _string-convert/imm32/name
29507 0x11/imm32/alloc-id:fake
29508 Single-int-var-in-mem/imm32/inouts
29509 0x11/imm32/alloc-id:fake
29510 Single-float-var-in-some-register/imm32/outputs
29511 0x11/imm32/alloc-id:fake
29512 _string_f3_0f_2a_convert_to_float/imm32/subx-name
29513 1/imm32/rm32-is-first-inout
29514 0/imm32/no-r32
29515 0/imm32/no-imm32
29516 0/imm32/no-imm8
29517 0/imm32/no-disp32
29518 0/imm32/no-xm32
29519 3/imm32/x32-is-first-output
29520 0x11/imm32/alloc-id:fake
29521 _Primitive-convert-reg-to-xreg/imm32/next
29522 _Primitive-convert-reg-to-xreg:
29523 0x11/imm32/alloc-id:fake:payload
29524
29525 0x11/imm32/alloc-id:fake
29526 _string-convert/imm32/name
29527 0x11/imm32/alloc-id:fake
29528 Single-int-var-in-some-register/imm32/inouts
29529 0x11/imm32/alloc-id:fake
29530 Single-float-var-in-some-register/imm32/outputs
29531 0x11/imm32/alloc-id:fake
29532 _string_f3_0f_2a_convert_to_float/imm32/subx-name
29533 1/imm32/rm32-is-first-inout
29534 0/imm32/no-r32
29535 0/imm32/no-imm32
29536 0/imm32/no-imm8
29537 0/imm32/no-disp32
29538 0/imm32/no-xm32
29539 3/imm32/x32-is-first-output
29540 0x11/imm32/alloc-id:fake
29541 _Primitive-convert-xmem-to-reg/imm32/next
29542
29543 _Primitive-convert-xmem-to-reg:
29544 0x11/imm32/alloc-id:fake:payload
29545
29546 0x11/imm32/alloc-id:fake
29547 _string-convert/imm32/name
29548 0x11/imm32/alloc-id:fake
29549 Single-float-var-in-mem/imm32/inouts
29550 0x11/imm32/alloc-id:fake
29551 Single-int-var-in-some-register/imm32/outputs
29552 0x11/imm32/alloc-id:fake
29553 _string_f3_0f_2d_convert_to_int/imm32/subx-name
29554 0/imm32/no-rm32
29555 3/imm32/r32-is-first-output
29556 0/imm32/no-imm32
29557 0/imm32/no-imm8
29558 0/imm32/no-disp32
29559 1/imm32/xm32-is-first-inout
29560 0/imm32/no-x32
29561 0x11/imm32/alloc-id:fake
29562 _Primitive-convert-xreg-to-reg/imm32/next
29563 _Primitive-convert-xreg-to-reg:
29564 0x11/imm32/alloc-id:fake:payload
29565
29566 0x11/imm32/alloc-id:fake
29567 _string-convert/imm32/name
29568 0x11/imm32/alloc-id:fake
29569 Single-float-var-in-some-register/imm32/inouts
29570 0x11/imm32/alloc-id:fake
29571 Single-int-var-in-some-register/imm32/outputs
29572 0x11/imm32/alloc-id:fake
29573 _string_f3_0f_2d_convert_to_int/imm32/subx-name
29574 0/imm32/no-rm32
29575 3/imm32/r32-is-first-output
29576 0/imm32/no-imm32
29577 0/imm32/no-imm8
29578 0/imm32/no-disp32
29579 1/imm32/xm32-is-first-inout
29580 0/imm32/no-x32
29581 0x11/imm32/alloc-id:fake
29582 _Primitive-truncate-xmem-to-reg/imm32/next
29583 _Primitive-truncate-xmem-to-reg:
29584 0x11/imm32/alloc-id:fake:payload
29585
29586 0x11/imm32/alloc-id:fake
29587 _string-truncate/imm32/name
29588 0x11/imm32/alloc-id:fake
29589 Single-float-var-in-mem/imm32/inouts
29590 0x11/imm32/alloc-id:fake
29591 Single-int-var-in-some-register/imm32/outputs
29592 0x11/imm32/alloc-id:fake
29593 _string_f3_0f_2c_truncate_to_int/imm32/subx-name
29594 0/imm32/no-rm32
29595 3/imm32/r32-is-first-output
29596 0/imm32/no-imm32
29597 0/imm32/no-imm8
29598 0/imm32/no-disp32
29599 1/imm32/xm32-is-first-inout
29600 0/imm32/no-x32
29601 0x11/imm32/alloc-id:fake
29602 _Primitive-truncate-xreg-to-reg/imm32/next
29603 _Primitive-truncate-xreg-to-reg:
29604 0x11/imm32/alloc-id:fake:payload
29605
29606 0x11/imm32/alloc-id:fake
29607 _string-truncate/imm32/name
29608 0x11/imm32/alloc-id:fake
29609 Single-float-var-in-some-register/imm32/inouts
29610 0x11/imm32/alloc-id:fake
29611 Single-int-var-in-some-register/imm32/outputs
29612 0x11/imm32/alloc-id:fake
29613 _string_f3_0f_2c_truncate_to_int/imm32/subx-name
29614 0/imm32/no-rm32
29615 3/imm32/r32-is-first-output
29616 0/imm32/no-imm32
29617 0/imm32/no-imm8
29618 0/imm32/no-disp32
29619 1/imm32/xm32-is-first-inout
29620 0/imm32/no-x32
29621 0x11/imm32/alloc-id:fake
29622 _Primitive-reinterpret-xmem-as-reg/imm32/next
29623
29624 _Primitive-reinterpret-xmem-as-reg:
29625 0x11/imm32/alloc-id:fake:payload
29626
29627 0x11/imm32/alloc-id:fake
29628 _string-reinterpret/imm32/name
29629 0x11/imm32/alloc-id:fake
29630 Single-float-var-in-mem/imm32/inouts
29631 0x11/imm32/alloc-id:fake
29632 Single-int-var-in-some-register/imm32/outputs
29633 0x11/imm32/alloc-id:fake
29634 _string_8b_->/imm32/subx-name
29635 0/imm32/no-rm32
29636 3/imm32/r32-is-first-output
29637 0/imm32/no-imm32
29638 0/imm32/no-imm8
29639 0/imm32/no-disp32
29640 1/imm32/xm32-is-first-inout
29641 0/imm32/no-x32
29642 0x11/imm32/alloc-id:fake
29643 _Primitive-reinterpret-mem-as-xreg/imm32/next
29644 _Primitive-reinterpret-mem-as-xreg:
29645 0x11/imm32/alloc-id:fake:payload
29646
29647 0x11/imm32/alloc-id:fake
29648 _string-reinterpret/imm32/name
29649 0x11/imm32/alloc-id:fake
29650 Single-int-var-in-mem/imm32/inouts
29651 0x11/imm32/alloc-id:fake
29652 Single-float-var-in-some-register/imm32/outputs
29653 0x11/imm32/alloc-id:fake
29654 _string_f3_0f_10_copy/imm32/subx-name
29655 1/imm32/rm32-is-first-inout
29656 0/imm32/no-r32
29657 0/imm32/no-imm32
29658 0/imm32/no-imm8
29659 0/imm32/no-disp32
29660 0/imm32/no-xm32
29661 3/imm32/x32-is-first-output
29662 0x11/imm32/alloc-id:fake
29663 _Primitive-copy-xreg-to-xreg/imm32/next
29664
29665 _Primitive-copy-xreg-to-xreg:
29666 0x11/imm32/alloc-id:fake:payload
29667
29668 0x11/imm32/alloc-id:fake
29669 _string-copy/imm32/name
29670 0x11/imm32/alloc-id:fake
29671 Single-float-var-in-some-register/imm32/inouts
29672 0x11/imm32/alloc-id:fake
29673 Single-float-var-in-some-register/imm32/outputs
29674 0x11/imm32/alloc-id:fake
29675 _string_f3_0f_11_copy/imm32/subx-name
29676 0/imm32/no-rm32
29677 0/imm32/no-r32
29678 0/imm32/no-imm32
29679 0/imm32/no-imm8
29680 0/imm32/no-disp32
29681 3/imm32/xm32-is-first-output
29682 1/imm32/x32-is-first-inout
29683 0x11/imm32/alloc-id:fake
29684 _Primitive-copy-xreg-to-mem/imm32/next
29685 _Primitive-copy-xreg-to-mem:
29686 0x11/imm32/alloc-id:fake:payload
29687
29688 0x11/imm32/alloc-id:fake
29689 _string-copy-to/imm32/name
29690 0x11/imm32/alloc-id:fake
29691 Two-args-float-stack-float-reg/imm32/inouts
29692 0/imm32/no-outputs
29693 0/imm32/no-outputs
29694 0x11/imm32/alloc-id:fake
29695 _string_f3_0f_11_copy/imm32/subx-name
29696 0/imm32/no-rm32
29697 0/imm32/no-r32
29698 0/imm32/no-imm32
29699 0/imm32/no-imm8
29700 0/imm32/no-disp32
29701 1/imm32/xm32-is-first-inout
29702 2/imm32/x32-is-second-inout
29703 0x11/imm32/alloc-id:fake
29704 _Primitive-copy-mem-to-xreg/imm32/next
29705 _Primitive-copy-mem-to-xreg:
29706 0x11/imm32/alloc-id:fake:payload
29707
29708 0x11/imm32/alloc-id:fake
29709 _string-copy/imm32/name
29710 0x11/imm32/alloc-id:fake
29711 Single-float-var-in-mem/imm32/inouts
29712 0x11/imm32/alloc-id:fake
29713 Single-float-var-in-some-register/imm32/outputs
29714 0x11/imm32/alloc-id:fake
29715 _string_f3_0f_10_copy/imm32/subx-name
29716 0/imm32/no-rm32
29717 0/imm32/no-r32
29718 0/imm32/no-imm32
29719 0/imm32/no-imm8
29720 0/imm32/no-disp32
29721 1/imm32/xm32-is-first-inout
29722 3/imm32/x32-is-first-output
29723 0x11/imm32/alloc-id:fake
29724 _Primitive-address-of-xmem/imm32/next
29725
29726 _Primitive-address-of-xmem:
29727 0x11/imm32/alloc-id:fake:payload
29728
29729 0x11/imm32/alloc-id:fake
29730 _string-address/imm32/name
29731 0x11/imm32/alloc-id:fake
29732 Single-float-var-in-mem/imm32/inouts
29733 0x11/imm32/alloc-id:fake
29734 Single-addr-var-in-some-register/imm32/outputs
29735 0x11/imm32/alloc-id:fake
29736 _string_8d_copy_address/imm32/subx-name
29737 1/imm32/rm32-is-first-inout
29738 3/imm32/r32-is-first-output
29739 0/imm32/no-imm32
29740 0/imm32/no-imm8
29741 0/imm32/no-disp32
29742 0/imm32/no-xm32
29743 0/imm32/no-x32
29744 0x11/imm32/alloc-id:fake
29745 _Primitive-add-xreg-to-xreg/imm32/next
29746
29747 _Primitive-add-xreg-to-xreg:
29748 0x11/imm32/alloc-id:fake:payload
29749
29750 0x11/imm32/alloc-id:fake
29751 _string-add/imm32/name
29752 0x11/imm32/alloc-id:fake
29753 Single-float-var-in-some-register/imm32/inouts
29754 0x11/imm32/alloc-id:fake
29755 Single-float-var-in-some-register/imm32/outputs
29756 0x11/imm32/alloc-id:fake
29757 _string_f3_0f_58_add/imm32/subx-name
29758 0/imm32/no-rm32
29759 0/imm32/no-r32
29760 0/imm32/no-imm32
29761 0/imm32/no-imm8
29762 0/imm32/no-disp32
29763 1/imm32/xm32-is-first-inout
29764 3/imm32/x32-is-first-output
29765 0x11/imm32/alloc-id:fake
29766 _Primitive-add-mem-to-xreg/imm32/next
29767 _Primitive-add-mem-to-xreg:
29768 0x11/imm32/alloc-id:fake:payload
29769
29770 0x11/imm32/alloc-id:fake
29771 _string-add/imm32/name
29772 0x11/imm32/alloc-id:fake
29773 Single-float-var-in-mem/imm32/inouts
29774 0x11/imm32/alloc-id:fake
29775 Single-float-var-in-some-register/imm32/outputs
29776 0x11/imm32/alloc-id:fake
29777 _string_f3_0f_58_add/imm32/subx-name
29778 0/imm32/no-rm32
29779 0/imm32/no-r32
29780 0/imm32/no-imm32
29781 0/imm32/no-imm8
29782 0/imm32/no-disp32
29783 1/imm32/xm32-is-first-inout
29784 3/imm32/x32-is-first-output
29785 0x11/imm32/alloc-id:fake
29786 _Primitive-subtract-xreg-from-xreg/imm32/next
29787
29788 _Primitive-subtract-xreg-from-xreg:
29789 0x11/imm32/alloc-id:fake:payload
29790
29791 0x11/imm32/alloc-id:fake
29792 _string-subtract/imm32/name
29793 0x11/imm32/alloc-id:fake
29794 Single-float-var-in-some-register/imm32/inouts
29795 0x11/imm32/alloc-id:fake
29796 Single-float-var-in-some-register/imm32/outputs
29797 0x11/imm32/alloc-id:fake
29798 _string_f3_0f_5c_subtract/imm32/subx-name
29799 0/imm32/no-rm32
29800 0/imm32/no-r32
29801 0/imm32/no-imm32
29802 0/imm32/no-imm8
29803 0/imm32/no-disp32
29804 1/imm32/xm32-is-first-inout
29805 3/imm32/x32-is-first-output
29806 0x11/imm32/alloc-id:fake
29807 _Primitive-subtract-mem-from-xreg/imm32/next
29808 _Primitive-subtract-mem-from-xreg:
29809 0x11/imm32/alloc-id:fake:payload
29810
29811 0x11/imm32/alloc-id:fake
29812 _string-subtract/imm32/name
29813 0x11/imm32/alloc-id:fake
29814 Single-float-var-in-mem/imm32/inouts
29815 0x11/imm32/alloc-id:fake
29816 Single-float-var-in-some-register/imm32/outputs
29817 0x11/imm32/alloc-id:fake
29818 _string_f3_0f_5c_subtract/imm32/subx-name
29819 0/imm32/no-rm32
29820 0/imm32/no-r32
29821 0/imm32/no-imm32
29822 0/imm32/no-imm8
29823 0/imm32/no-disp32
29824 1/imm32/xm32-is-first-inout
29825 3/imm32/x32-is-first-output
29826 0x11/imm32/alloc-id:fake
29827 _Primitive-multiply-xreg-by-xreg/imm32/next
29828
29829 _Primitive-multiply-xreg-by-xreg:
29830 0x11/imm32/alloc-id:fake:payload
29831
29832 0x11/imm32/alloc-id:fake
29833 _string-multiply/imm32/name
29834 0x11/imm32/alloc-id:fake
29835 Single-float-var-in-some-register/imm32/inouts
29836 0x11/imm32/alloc-id:fake
29837 Single-float-var-in-some-register/imm32/outputs
29838 0x11/imm32/alloc-id:fake
29839 _string_f3_0f_59_multiply/imm32/subx-name
29840 0/imm32/no-rm32
29841 0/imm32/no-r32
29842 0/imm32/no-imm32
29843 0/imm32/no-imm8
29844 0/imm32/no-disp32
29845 1/imm32/xm32-is-first-inout
29846 3/imm32/x32-is-first-output
29847 0x11/imm32/alloc-id:fake
29848 _Primitive-multiply-xreg-by-mem/imm32/next
29849 _Primitive-multiply-xreg-by-mem:
29850 0x11/imm32/alloc-id:fake:payload
29851
29852 0x11/imm32/alloc-id:fake
29853 _string-multiply/imm32/name
29854 0x11/imm32/alloc-id:fake
29855 Single-float-var-in-mem/imm32/inouts
29856 0x11/imm32/alloc-id:fake
29857 Single-float-var-in-some-register/imm32/outputs
29858 0x11/imm32/alloc-id:fake
29859 _string_f3_0f_59_multiply/imm32/subx-name
29860 0/imm32/no-rm32
29861 0/imm32/no-r32
29862 0/imm32/no-imm32
29863 0/imm32/no-imm8
29864 0/imm32/no-disp32
29865 1/imm32/xm32-is-first-inout
29866 3/imm32/x32-is-first-output
29867 0x11/imm32/alloc-id:fake
29868 _Primitive-divide-xreg-by-xreg/imm32/next
29869
29870 _Primitive-divide-xreg-by-xreg:
29871 0x11/imm32/alloc-id:fake:payload
29872
29873 0x11/imm32/alloc-id:fake
29874 _string-divide/imm32/name
29875 0x11/imm32/alloc-id:fake
29876 Single-float-var-in-some-register/imm32/inouts
29877 0x11/imm32/alloc-id:fake
29878 Single-float-var-in-some-register/imm32/outputs
29879 0x11/imm32/alloc-id:fake
29880 _string_f3_0f_5e_divide/imm32/subx-name
29881 0/imm32/no-rm32
29882 0/imm32/no-r32
29883 0/imm32/no-imm32
29884 0/imm32/no-imm8
29885 0/imm32/no-disp32
29886 1/imm32/xm32-is-first-inout
29887 3/imm32/x32-is-first-output
29888 0x11/imm32/alloc-id:fake
29889 _Primitive-divide-xreg-by-mem/imm32/next
29890 _Primitive-divide-xreg-by-mem:
29891 0x11/imm32/alloc-id:fake:payload
29892
29893 0x11/imm32/alloc-id:fake
29894 _string-divide/imm32/name
29895 0x11/imm32/alloc-id:fake
29896 Single-float-var-in-mem/imm32/inouts
29897 0x11/imm32/alloc-id:fake
29898 Single-float-var-in-some-register/imm32/outputs
29899 0x11/imm32/alloc-id:fake
29900 _string_f3_0f_5e_divide/imm32/subx-name
29901 0/imm32/no-rm32
29902 0/imm32/no-r32
29903 0/imm32/no-imm32
29904 0/imm32/no-imm8
29905 0/imm32/no-disp32
29906 1/imm32/xm32-is-first-inout
29907 3/imm32/x32-is-first-output
29908 0x11/imm32/alloc-id:fake
29909 _Primitive-max-xreg-with-xreg/imm32/next
29910
29911 _Primitive-max-xreg-with-xreg:
29912 0x11/imm32/alloc-id:fake:payload
29913
29914 0x11/imm32/alloc-id:fake
29915 _string-max/imm32/name
29916 0x11/imm32/alloc-id:fake
29917 Single-float-var-in-some-register/imm32/inouts
29918 0x11/imm32/alloc-id:fake
29919 Single-float-var-in-some-register/imm32/outputs
29920 0x11/imm32/alloc-id:fake
29921 _string_f3_0f_5f_max/imm32/subx-name
29922 0/imm32/no-rm32
29923 0/imm32/no-r32
29924 0/imm32/no-imm32
29925 0/imm32/no-imm8
29926 0/imm32/no-disp32
29927 1/imm32/xm32-is-first-inout
29928 3/imm32/x32-is-first-output
29929 0x11/imm32/alloc-id:fake
29930 _Primitive-max-xreg-with-mem/imm32/next
29931 _Primitive-max-xreg-with-mem:
29932 0x11/imm32/alloc-id:fake:payload
29933
29934 0x11/imm32/alloc-id:fake
29935 _string-max/imm32/name
29936 0x11/imm32/alloc-id:fake
29937 Single-float-var-in-mem/imm32/inouts
29938 0x11/imm32/alloc-id:fake
29939 Single-float-var-in-some-register/imm32/outputs
29940 0x11/imm32/alloc-id:fake
29941 _string_f3_0f_5f_max/imm32/subx-name
29942 0/imm32/no-rm32
29943 0/imm32/no-r32
29944 0/imm32/no-imm32
29945 0/imm32/no-imm8
29946 0/imm32/no-disp32
29947 1/imm32/xm32-is-first-inout
29948 3/imm32/x32-is-first-output
29949 0x11/imm32/alloc-id:fake
29950 _Primitive-min-xreg-with-xreg/imm32/next
29951
29952 _Primitive-min-xreg-with-xreg:
29953 0x11/imm32/alloc-id:fake:payload
29954
29955 0x11/imm32/alloc-id:fake
29956 _string-min/imm32/name
29957 0x11/imm32/alloc-id:fake
29958 Single-float-var-in-some-register/imm32/inouts
29959 0x11/imm32/alloc-id:fake
29960 Single-float-var-in-some-register/imm32/outputs
29961 0x11/imm32/alloc-id:fake
29962 _string_f3_0f_5d_min/imm32/subx-name
29963 0/imm32/no-rm32
29964 0/imm32/no-r32
29965 0/imm32/no-imm32
29966 0/imm32/no-imm8
29967 0/imm32/no-disp32
29968 1/imm32/xm32-is-first-inout
29969 3/imm32/x32-is-first-output
29970 0x11/imm32/alloc-id:fake
29971 _Primitive-min-xreg-with-mem/imm32/next
29972 _Primitive-min-xreg-with-mem:
29973 0x11/imm32/alloc-id:fake:payload
29974
29975 0x11/imm32/alloc-id:fake
29976 _string-min/imm32/name
29977 0x11/imm32/alloc-id:fake
29978 Single-float-var-in-mem/imm32/inouts
29979 0x11/imm32/alloc-id:fake
29980 Single-float-var-in-some-register/imm32/outputs
29981 0x11/imm32/alloc-id:fake
29982 _string_f3_0f_5d_min/imm32/subx-name
29983 0/imm32/no-rm32
29984 0/imm32/no-r32
29985 0/imm32/no-imm32
29986 0/imm32/no-imm8
29987 0/imm32/no-disp32
29988 1/imm32/xm32-is-first-inout
29989 3/imm32/x32-is-first-output
29990 0x11/imm32/alloc-id:fake
29991 _Primitive-reciprocal-xreg-to-xreg/imm32/next
29992
29993 _Primitive-reciprocal-xreg-to-xreg:
29994 0x11/imm32/alloc-id:fake:payload
29995
29996 0x11/imm32/alloc-id:fake
29997 _string-reciprocal/imm32/name
29998 0x11/imm32/alloc-id:fake
29999 Single-float-var-in-some-register/imm32/inouts
30000 0x11/imm32/alloc-id:fake
30001 Single-float-var-in-some-register/imm32/outputs
30002 0x11/imm32/alloc-id:fake
30003 _string_f3_0f_53_reciprocal/imm32/subx-name
30004 0/imm32/no-rm32
30005 0/imm32/no-r32
30006 0/imm32/no-imm32
30007 0/imm32/no-imm8
30008 0/imm32/no-disp32
30009 1/imm32/xm32-is-first-inout
30010 3/imm32/x32-is-first-output
30011 0x11/imm32/alloc-id:fake
30012 _Primitive-reciprocal-mem-to-xreg/imm32/next
30013 _Primitive-reciprocal-mem-to-xreg:
30014 0x11/imm32/alloc-id:fake:payload
30015
30016 0x11/imm32/alloc-id:fake
30017 _string-reciprocal/imm32/name
30018 0x11/imm32/alloc-id:fake
30019 Single-float-var-in-mem/imm32/inouts
30020 0x11/imm32/alloc-id:fake
30021 Single-float-var-in-some-register/imm32/outputs
30022 0x11/imm32/alloc-id:fake
30023 _string_f3_0f_53_reciprocal/imm32/subx-name
30024 0/imm32/no-rm32
30025 0/imm32/no-r32
30026 0/imm32/no-imm32
30027 0/imm32/no-imm8
30028 0/imm32/no-disp32
30029 1/imm32/xm32-is-first-inout
30030 3/imm32/x32-is-first-output
30031 0x11/imm32/alloc-id:fake
30032 _Primitive-square-root-xreg-to-xreg/imm32/next
30033
30034 _Primitive-square-root-xreg-to-xreg:
30035 0x11/imm32/alloc-id:fake:payload
30036
30037 0x11/imm32/alloc-id:fake
30038 _string-square-root/imm32/name
30039 0x11/imm32/alloc-id:fake
30040 Single-float-var-in-some-register/imm32/inouts
30041 0x11/imm32/alloc-id:fake
30042 Single-float-var-in-some-register/imm32/outputs
30043 0x11/imm32/alloc-id:fake
30044 _string_f3_0f_51_square_root/imm32/subx-name
30045 0/imm32/no-rm32
30046 0/imm32/no-r32
30047 0/imm32/no-imm32
30048 0/imm32/no-imm8
30049 0/imm32/no-disp32
30050 1/imm32/xm32-is-first-inout
30051 3/imm32/x32-is-first-output
30052 0x11/imm32/alloc-id:fake
30053 _Primitive-square-root-mem-to-xreg/imm32/next
30054 _Primitive-square-root-mem-to-xreg:
30055 0x11/imm32/alloc-id:fake:payload
30056
30057 0x11/imm32/alloc-id:fake
30058 _string-square-root/imm32/name
30059 0x11/imm32/alloc-id:fake
30060 Single-float-var-in-mem/imm32/inouts
30061 0x11/imm32/alloc-id:fake
30062 Single-float-var-in-some-register/imm32/outputs
30063 0x11/imm32/alloc-id:fake
30064 _string_f3_0f_51_square_root/imm32/subx-name
30065 0/imm32/no-rm32
30066 0/imm32/no-r32
30067 0/imm32/no-imm32
30068 0/imm32/no-imm8
30069 0/imm32/no-disp32
30070 1/imm32/xm32-is-first-inout
30071 3/imm32/x32-is-first-output
30072 0x11/imm32/alloc-id:fake
30073 _Primitive-inverse-square-root-xreg-to-xreg/imm32/next
30074
30075 _Primitive-inverse-square-root-xreg-to-xreg:
30076 0x11/imm32/alloc-id:fake:payload
30077
30078 0x11/imm32/alloc-id:fake
30079 _string-inverse-square-root/imm32/name
30080 0x11/imm32/alloc-id:fake
30081 Single-float-var-in-some-register/imm32/inouts
30082 0x11/imm32/alloc-id:fake
30083 Single-float-var-in-some-register/imm32/outputs
30084 0x11/imm32/alloc-id:fake
30085 _string_f3_0f_52_inverse_square_root/imm32/subx-name
30086 0/imm32/no-rm32
30087 0/imm32/no-r32
30088 0/imm32/no-imm32
30089 0/imm32/no-imm8
30090 0/imm32/no-disp32
30091 1/imm32/xm32-is-first-inout
30092 3/imm32/x32-is-first-output
30093 0x11/imm32/alloc-id:fake
30094 _Primitive-inverse-square-root-mem-to-xreg/imm32/next
30095 _Primitive-inverse-square-root-mem-to-xreg:
30096 0x11/imm32/alloc-id:fake:payload
30097
30098 0x11/imm32/alloc-id:fake
30099 _string-inverse-square-root/imm32/name
30100 0x11/imm32/alloc-id:fake
30101 Single-float-var-in-mem/imm32/inouts
30102 0x11/imm32/alloc-id:fake
30103 Single-float-var-in-some-register/imm32/outputs
30104 0x11/imm32/alloc-id:fake
30105 _string_f3_0f_52_inverse_square_root/imm32/subx-name
30106 0/imm32/no-rm32
30107 0/imm32/no-r32
30108 0/imm32/no-imm32
30109 0/imm32/no-imm8
30110 0/imm32/no-disp32
30111 1/imm32/xm32-is-first-inout
30112 3/imm32/x32-is-first-output
30113 0x11/imm32/alloc-id:fake
30114 _Primitive-compare-xreg-with-xreg/imm32/next
30115
30116 _Primitive-compare-xreg-with-xreg:
30117 0x11/imm32/alloc-id:fake:payload
30118
30119 0x11/imm32/alloc-id:fake
30120 _string-compare/imm32/name
30121 0x11/imm32/alloc-id:fake
30122 Two-float-args-in-regs/imm32/inouts
30123 0/imm32/no-outputs
30124 0/imm32/no-outputs
30125 0x11/imm32/alloc-id:fake
30126 _string_0f_2f_compare/imm32/subx-name
30127 0/imm32/no-rm32
30128 0/imm32/no-r32
30129 0/imm32/no-imm32
30130 0/imm32/no-imm8
30131 0/imm32/no-disp32
30132 1/imm32/xm32-is-first-inout
30133 2/imm32/x32-is-second-inout
30134 0x11/imm32/alloc-id:fake
30135 _Primitive-compare-xreg-with-mem/imm32/next
30136 _Primitive-compare-xreg-with-mem:
30137 0x11/imm32/alloc-id:fake:payload
30138
30139 0x11/imm32/alloc-id:fake
30140 _string-compare/imm32/name
30141 0x11/imm32/alloc-id:fake
30142 Two-args-float-reg-float-stack/imm32/inouts
30143 0/imm32/no-outputs
30144 0/imm32/no-outputs
30145 0x11/imm32/alloc-id:fake
30146 _string_0f_2f_compare/imm32/subx-name
30147 0/imm32/no-rm32
30148 0/imm32/no-r32
30149 0/imm32/no-imm32
30150 0/imm32/no-imm8
30151 0/imm32/no-disp32
30152 2/imm32/xm32-is-second-inout
30153 1/imm32/x32-is-first-inout
30154 0x11/imm32/alloc-id:fake
30155 _Primitive-break-if-addr</imm32/next
30156
30157 _Primitive-break-if-addr<:
30158 0x11/imm32/alloc-id:fake:payload
30159 0x11/imm32/alloc-id:fake
30160 _string-break-if-addr</imm32/name
30161 0/imm32/no-inouts
30162 0/imm32/no-inouts
30163 0/imm32/no-outputs
30164 0/imm32/no-outputs
30165 0x11/imm32/alloc-id:fake
30166 _string_0f_82_jump_break/imm32/subx-name
30167 0/imm32/no-rm32
30168 0/imm32/no-r32
30169 0/imm32/no-imm32
30170 0/imm32/no-imm8
30171 0/imm32/no-disp32
30172 0/imm32/no-xm32
30173 0/imm32/no-x32
30174 0x11/imm32/alloc-id:fake
30175 _Primitive-break-if-addr>=/imm32/next
30176 _Primitive-break-if-addr>=:
30177 0x11/imm32/alloc-id:fake:payload
30178 0x11/imm32/alloc-id:fake
30179 _string-break-if-addr>=/imm32/name
30180 0/imm32/no-inouts
30181 0/imm32/no-inouts
30182 0/imm32/no-outputs
30183 0/imm32/no-outputs
30184 0x11/imm32/alloc-id:fake
30185 _string_0f_83_jump_break/imm32/subx-name
30186 0/imm32/no-rm32
30187 0/imm32/no-r32
30188 0/imm32/no-imm32
30189 0/imm32/no-imm8
30190 0/imm32/no-disp32
30191 0/imm32/no-xm32
30192 0/imm32/no-x32
30193 0x11/imm32/alloc-id:fake
30194 _Primitive-break-if-=/imm32/next
30195 _Primitive-break-if-=:
30196 0x11/imm32/alloc-id:fake:payload
30197 0x11/imm32/alloc-id:fake
30198 _string-break-if-=/imm32/name
30199 0/imm32/no-inouts
30200 0/imm32/no-inouts
30201 0/imm32/no-outputs
30202 0/imm32/no-outputs
30203 0x11/imm32/alloc-id:fake
30204 _string_0f_84_jump_break/imm32/subx-name
30205 0/imm32/no-rm32
30206 0/imm32/no-r32
30207 0/imm32/no-imm32
30208 0/imm32/no-imm8
30209 0/imm32/no-disp32
30210 0/imm32/no-xm32
30211 0/imm32/no-x32
30212 0x11/imm32/alloc-id:fake
30213 _Primitive-break-if-!=/imm32/next
30214 _Primitive-break-if-!=:
30215 0x11/imm32/alloc-id:fake:payload
30216 0x11/imm32/alloc-id:fake
30217 _string-break-if-!=/imm32/name
30218 0/imm32/no-inouts
30219 0/imm32/no-inouts
30220 0/imm32/no-outputs
30221 0/imm32/no-outputs
30222 0x11/imm32/alloc-id:fake
30223 _string_0f_85_jump_break/imm32/subx-name
30224 0/imm32/no-rm32
30225 0/imm32/no-r32
30226 0/imm32/no-imm32
30227 0/imm32/no-imm8
30228 0/imm32/no-disp32
30229 0/imm32/no-xm32
30230 0/imm32/no-x32
30231 0x11/imm32/alloc-id:fake
30232 _Primitive-break-if-addr<=/imm32/next
30233 _Primitive-break-if-addr<=:
30234 0x11/imm32/alloc-id:fake:payload
30235 0x11/imm32/alloc-id:fake
30236 _string-break-if-addr<=/imm32/name
30237 0/imm32/no-inouts
30238 0/imm32/no-inouts
30239 0/imm32/no-outputs
30240 0/imm32/no-outputs
30241 0x11/imm32/alloc-id:fake
30242 _string_0f_86_jump_break/imm32/subx-name
30243 0/imm32/no-rm32
30244 0/imm32/no-r32
30245 0/imm32/no-imm32
30246 0/imm32/no-imm8
30247 0/imm32/no-disp32
30248 0/imm32/no-xm32
30249 0/imm32/no-x32
30250 0x11/imm32/alloc-id:fake
30251 _Primitive-break-if-addr>/imm32/next
30252 _Primitive-break-if-addr>:
30253 0x11/imm32/alloc-id:fake:payload
30254 0x11/imm32/alloc-id:fake
30255 _string-break-if-addr>/imm32/name
30256 0/imm32/no-inouts
30257 0/imm32/no-inouts
30258 0/imm32/no-outputs
30259 0/imm32/no-outputs
30260 0x11/imm32/alloc-id:fake
30261 _string_0f_87_jump_break/imm32/subx-name
30262 0/imm32/no-rm32
30263 0/imm32/no-r32
30264 0/imm32/no-imm32
30265 0/imm32/no-imm8
30266 0/imm32/no-disp32
30267 0/imm32/no-xm32
30268 0/imm32/no-x32
30269 0x11/imm32/alloc-id:fake
30270 _Primitive-break-if-</imm32/next
30271 _Primitive-break-if-<:
30272 0x11/imm32/alloc-id:fake:payload
30273 0x11/imm32/alloc-id:fake
30274 _string-break-if-</imm32/name
30275 0/imm32/no-inouts
30276 0/imm32/no-inouts
30277 0/imm32/no-outputs
30278 0/imm32/no-outputs
30279 0x11/imm32/alloc-id:fake
30280 _string_0f_8c_jump_break/imm32/subx-name
30281 0/imm32/no-rm32
30282 0/imm32/no-r32
30283 0/imm32/no-imm32
30284 0/imm32/no-imm8
30285 0/imm32/no-disp32
30286 0/imm32/no-xm32
30287 0/imm32/no-x32
30288 0x11/imm32/alloc-id:fake
30289 _Primitive-break-if->=/imm32/next
30290 _Primitive-break-if->=:
30291 0x11/imm32/alloc-id:fake:payload
30292 0x11/imm32/alloc-id:fake
30293 _string-break-if->=/imm32/name
30294 0/imm32/no-inouts
30295 0/imm32/no-inouts
30296 0/imm32/no-outputs
30297 0/imm32/no-outputs
30298 0x11/imm32/alloc-id:fake
30299 _string_0f_8d_jump_break/imm32/subx-name
30300 0/imm32/no-rm32
30301 0/imm32/no-r32
30302 0/imm32/no-imm32
30303 0/imm32/no-imm8
30304 0/imm32/no-disp32
30305 0/imm32/no-xm32
30306 0/imm32/no-x32
30307 0x11/imm32/alloc-id:fake
30308 _Primitive-break-if-<=/imm32/next
30309 _Primitive-break-if-<=:
30310 0x11/imm32/alloc-id:fake:payload
30311 0x11/imm32/alloc-id:fake
30312 _string-break-if-<=/imm32/name
30313 0/imm32/no-inouts
30314 0/imm32/no-inouts
30315 0/imm32/no-outputs
30316 0/imm32/no-outputs
30317 0x11/imm32/alloc-id:fake
30318 _string_0f_8e_jump_break/imm32/subx-name
30319 0/imm32/no-rm32
30320 0/imm32/no-r32
30321 0/imm32/no-imm32
30322 0/imm32/no-imm8
30323 0/imm32/no-disp32
30324 0/imm32/no-xm32
30325 0/imm32/no-x32
30326 0x11/imm32/alloc-id:fake
30327 _Primitive-break-if->/imm32/next
30328 _Primitive-break-if->:
30329 0x11/imm32/alloc-id:fake:payload
30330 0x11/imm32/alloc-id:fake
30331 _string-break-if->/imm32/name
30332 0/imm32/no-inouts
30333 0/imm32/no-inouts
30334 0/imm32/no-outputs
30335 0/imm32/no-outputs
30336 0x11/imm32/alloc-id:fake
30337 _string_0f_8f_jump_break/imm32/subx-name
30338 0/imm32/no-rm32
30339 0/imm32/no-r32
30340 0/imm32/no-imm32
30341 0/imm32/no-imm8
30342 0/imm32/no-disp32
30343 0/imm32/no-xm32
30344 0/imm32/no-x32
30345 0x11/imm32/alloc-id:fake
30346 _Primitive-break/imm32/next
30347 _Primitive-break:
30348 0x11/imm32/alloc-id:fake:payload
30349 0x11/imm32/alloc-id:fake
30350 _string-break/imm32/name
30351 0/imm32/no-inouts
30352 0/imm32/no-inouts
30353 0/imm32/no-outputs
30354 0/imm32/no-outputs
30355 0x11/imm32/alloc-id:fake
30356 _string_e9_jump_break/imm32/subx-name
30357 0/imm32/no-rm32
30358 0/imm32/no-r32
30359 0/imm32/no-imm32
30360 0/imm32/no-imm8
30361 0/imm32/no-disp32
30362 0/imm32/no-xm32
30363 0/imm32/no-x32
30364 0x11/imm32/alloc-id:fake
30365 _Primitive-loop-if-addr</imm32/next
30366 _Primitive-loop-if-addr<:
30367 0x11/imm32/alloc-id:fake:payload
30368 0x11/imm32/alloc-id:fake
30369 _string-loop-if-addr</imm32/name
30370 0/imm32/no-inouts
30371 0/imm32/no-inouts
30372 0/imm32/no-outputs
30373 0/imm32/no-outputs
30374 0x11/imm32/alloc-id:fake
30375 _string_0f_82_jump_loop/imm32/subx-name
30376 0/imm32/no-rm32
30377 0/imm32/no-r32
30378 0/imm32/no-imm32
30379 0/imm32/no-imm8
30380 0/imm32/no-disp32
30381 0/imm32/no-xm32
30382 0/imm32/no-x32
30383 0x11/imm32/alloc-id:fake
30384 _Primitive-loop-if-addr>=/imm32/next
30385 _Primitive-loop-if-addr>=:
30386 0x11/imm32/alloc-id:fake:payload
30387 0x11/imm32/alloc-id:fake
30388 _string-loop-if-addr>=/imm32/name
30389 0/imm32/no-inouts
30390 0/imm32/no-inouts
30391 0/imm32/no-outputs
30392 0/imm32/no-outputs
30393 0x11/imm32/alloc-id:fake
30394 _string_0f_83_jump_loop/imm32/subx-name
30395 0/imm32/no-rm32
30396 0/imm32/no-r32
30397 0/imm32/no-imm32
30398 0/imm32/no-imm8
30399 0/imm32/no-disp32
30400 0/imm32/no-xm32
30401 0/imm32/no-x32
30402 0x11/imm32/alloc-id:fake
30403 _Primitive-loop-if-=/imm32/next
30404 _Primitive-loop-if-=:
30405 0x11/imm32/alloc-id:fake:payload
30406 0x11/imm32/alloc-id:fake
30407 _string-loop-if-=/imm32/name
30408 0/imm32/no-inouts
30409 0/imm32/no-inouts
30410 0/imm32/no-outputs
30411 0/imm32/no-outputs
30412 0x11/imm32/alloc-id:fake
30413 _string_0f_84_jump_loop/imm32/subx-name
30414 0/imm32/no-rm32
30415 0/imm32/no-r32
30416 0/imm32/no-imm32
30417 0/imm32/no-imm8
30418 0/imm32/no-disp32
30419 0/imm32/no-xm32
30420 0/imm32/no-x32
30421 0x11/imm32/alloc-id:fake
30422 _Primitive-loop-if-!=/imm32/next
30423 _Primitive-loop-if-!=:
30424 0x11/imm32/alloc-id:fake:payload
30425 0x11/imm32/alloc-id:fake
30426 _string-loop-if-!=/imm32/name
30427 0/imm32/no-inouts
30428 0/imm32/no-inouts
30429 0/imm32/no-outputs
30430 0/imm32/no-outputs
30431 0x11/imm32/alloc-id:fake
30432 _string_0f_85_jump_loop/imm32/subx-name
30433 0/imm32/no-rm32
30434 0/imm32/no-r32
30435 0/imm32/no-imm32
30436 0/imm32/no-imm8
30437 0/imm32/no-disp32
30438 0/imm32/no-xm32
30439 0/imm32/no-x32
30440 0x11/imm32/alloc-id:fake
30441 _Primitive-loop-if-addr<=/imm32/next
30442 _Primitive-loop-if-addr<=:
30443 0x11/imm32/alloc-id:fake:payload
30444 0x11/imm32/alloc-id:fake
30445 _string-loop-if-addr<=/imm32/name
30446 0/imm32/no-inouts
30447 0/imm32/no-inouts
30448 0/imm32/no-outputs
30449 0/imm32/no-outputs
30450 0x11/imm32/alloc-id:fake
30451 _string_0f_86_jump_loop/imm32/subx-name
30452 0/imm32/no-rm32
30453 0/imm32/no-r32
30454 0/imm32/no-imm32
30455 0/imm32/no-imm8
30456 0/imm32/no-disp32
30457 0/imm32/no-xm32
30458 0/imm32/no-x32
30459 0x11/imm32/alloc-id:fake
30460 _Primitive-loop-if-addr>/imm32/next
30461 _Primitive-loop-if-addr>:
30462 0x11/imm32/alloc-id:fake:payload
30463 0x11/imm32/alloc-id:fake
30464 _string-loop-if-addr>/imm32/name
30465 0/imm32/no-inouts
30466 0/imm32/no-inouts
30467 0/imm32/no-outputs
30468 0/imm32/no-outputs
30469 0x11/imm32/alloc-id:fake
30470 _string_0f_87_jump_loop/imm32/subx-name
30471 0/imm32/no-rm32
30472 0/imm32/no-r32
30473 0/imm32/no-imm32
30474 0/imm32/no-imm8
30475 0/imm32/no-disp32
30476 0/imm32/no-xm32
30477 0/imm32/no-x32
30478 0x11/imm32/alloc-id:fake
30479 _Primitive-loop-if-</imm32/next
30480 _Primitive-loop-if-<:
30481 0x11/imm32/alloc-id:fake:payload
30482 0x11/imm32/alloc-id:fake
30483 _string-loop-if-</imm32/name
30484 0/imm32/no-inouts
30485 0/imm32/no-inouts
30486 0/imm32/no-outputs
30487 0/imm32/no-outputs
30488 0x11/imm32/alloc-id:fake
30489 _string_0f_8c_jump_loop/imm32/subx-name
30490 0/imm32/no-rm32
30491 0/imm32/no-r32
30492 0/imm32/no-imm32
30493 0/imm32/no-imm8
30494 0/imm32/no-disp32
30495 0/imm32/no-xm32
30496 0/imm32/no-x32
30497 0x11/imm32/alloc-id:fake
30498 _Primitive-loop-if->=/imm32/next
30499 _Primitive-loop-if->=:
30500 0x11/imm32/alloc-id:fake:payload
30501 0x11/imm32/alloc-id:fake
30502 _string-loop-if->=/imm32/name
30503 0/imm32/no-inouts
30504 0/imm32/no-inouts
30505 0/imm32/no-outputs
30506 0/imm32/no-outputs
30507 0x11/imm32/alloc-id:fake
30508 _string_0f_8d_jump_loop/imm32/subx-name
30509 0/imm32/no-rm32
30510 0/imm32/no-r32
30511 0/imm32/no-imm32
30512 0/imm32/no-imm8
30513 0/imm32/no-disp32
30514 0/imm32/no-xm32
30515 0/imm32/no-x32
30516 0x11/imm32/alloc-id:fake
30517 _Primitive-loop-if-<=/imm32/next
30518 _Primitive-loop-if-<=:
30519 0x11/imm32/alloc-id:fake:payload
30520 0x11/imm32/alloc-id:fake
30521 _string-loop-if-<=/imm32/name
30522 0/imm32/no-inouts
30523 0/imm32/no-inouts
30524 0/imm32/no-outputs
30525 0/imm32/no-outputs
30526 0x11/imm32/alloc-id:fake
30527 _string_0f_8e_jump_loop/imm32/subx-name
30528 0/imm32/no-rm32
30529 0/imm32/no-r32
30530 0/imm32/no-imm32
30531 0/imm32/no-imm8
30532 0/imm32/no-disp32
30533 0/imm32/no-xm32
30534 0/imm32/no-x32
30535 0x11/imm32/alloc-id:fake
30536 _Primitive-loop-if->/imm32/next
30537 _Primitive-loop-if->:
30538 0x11/imm32/alloc-id:fake:payload
30539 0x11/imm32/alloc-id:fake
30540 _string-loop-if->/imm32/name
30541 0/imm32/no-inouts
30542 0/imm32/no-inouts
30543 0/imm32/no-outputs
30544 0/imm32/no-outputs
30545 0x11/imm32/alloc-id:fake
30546 _string_0f_8f_jump_loop/imm32/subx-name
30547 0/imm32/no-rm32
30548 0/imm32/no-r32
30549 0/imm32/no-imm32
30550 0/imm32/no-imm8
30551 0/imm32/no-disp32
30552 0/imm32/no-xm32
30553 0/imm32/no-x32
30554 0x11/imm32/alloc-id:fake
30555 _Primitive-loop/imm32/next
30556 _Primitive-loop:
30557 0x11/imm32/alloc-id:fake:payload
30558 0x11/imm32/alloc-id:fake
30559 _string-loop/imm32/name
30560 0/imm32/no-inouts
30561 0/imm32/no-inouts
30562 0/imm32/no-outputs
30563 0/imm32/no-outputs
30564 0x11/imm32/alloc-id:fake
30565 _string_e9_jump_loop/imm32/subx-name
30566 0/imm32/no-rm32
30567 0/imm32/no-r32
30568 0/imm32/no-imm32
30569 0/imm32/no-imm8
30570 0/imm32/no-disp32
30571 0/imm32/no-xm32
30572 0/imm32/no-x32
30573 0x11/imm32/alloc-id:fake
30574 _Primitive-break-if-addr<-named/imm32/next
30575
30576 _Primitive-break-if-addr<-named:
30577 0x11/imm32/alloc-id:fake:payload
30578 0x11/imm32/alloc-id:fake
30579 _string-break-if-addr</imm32/name
30580 0x11/imm32/alloc-id:fake
30581 Single-lit-var/imm32/inouts
30582 0/imm32/no-outputs
30583 0/imm32/no-outputs
30584 0x11/imm32/alloc-id:fake
30585 _string_0f_82_jump_label/imm32/subx-name
30586 0/imm32/no-rm32
30587 0/imm32/no-r32
30588 0/imm32/no-imm32
30589 0/imm32/no-imm8
30590 1/imm32/disp32-is-first-inout
30591 0/imm32/no-xm32
30592 0/imm32/no-x32
30593 0x11/imm32/alloc-id:fake
30594 _Primitive-break-if-addr>=-named/imm32/next
30595 _Primitive-break-if-addr>=-named:
30596 0x11/imm32/alloc-id:fake:payload
30597 0x11/imm32/alloc-id:fake
30598 _string-break-if-addr>=/imm32/name
30599 0x11/imm32/alloc-id:fake
30600 Single-lit-var/imm32/inouts
30601 0/imm32/no-outputs
30602 0/imm32/no-outputs
30603 0x11/imm32/alloc-id:fake
30604 _string_0f_83_jump_label/imm32/subx-name
30605 0/imm32/no-rm32
30606 0/imm32/no-r32
30607 0/imm32/no-imm32
30608 0/imm32/no-imm8
30609 1/imm32/disp32-is-first-inout
30610 0/imm32/no-xm32
30611 0/imm32/no-x32
30612 0x11/imm32/alloc-id:fake
30613 _Primitive-break-if-=-named/imm32/next
30614 _Primitive-break-if-=-named:
30615 0x11/imm32/alloc-id:fake:payload
30616 0x11/imm32/alloc-id:fake
30617 _string-break-if-=/imm32/name
30618 0x11/imm32/alloc-id:fake
30619 Single-lit-var/imm32/inouts
30620 0/imm32/no-outputs
30621 0/imm32/no-outputs
30622 0x11/imm32/alloc-id:fake
30623 _string_0f_84_jump_label/imm32/subx-name
30624 0/imm32/no-rm32
30625 0/imm32/no-r32
30626 0/imm32/no-imm32
30627 0/imm32/no-imm8
30628 1/imm32/disp32-is-first-inout
30629 0/imm32/no-xm32
30630 0/imm32/no-x32
30631 0x11/imm32/alloc-id:fake
30632 _Primitive-break-if-!=-named/imm32/next
30633 _Primitive-break-if-!=-named:
30634 0x11/imm32/alloc-id:fake:payload
30635 0x11/imm32/alloc-id:fake
30636 _string-break-if-!=/imm32/name
30637 0x11/imm32/alloc-id:fake
30638 Single-lit-var/imm32/inouts
30639 0/imm32/no-outputs
30640 0/imm32/no-outputs
30641 0x11/imm32/alloc-id:fake
30642 _string_0f_85_jump_label/imm32/subx-name
30643 0/imm32/no-rm32
30644 0/imm32/no-r32
30645 0/imm32/no-imm32
30646 0/imm32/no-imm8
30647 1/imm32/disp32-is-first-inout
30648 0/imm32/no-xm32
30649 0/imm32/no-x32
30650 0x11/imm32/alloc-id:fake
30651 _Primitive-break-if-addr<=-named/imm32/next
30652 _Primitive-break-if-addr<=-named:
30653 0x11/imm32/alloc-id:fake:payload
30654 0x11/imm32/alloc-id:fake
30655 _string-break-if-addr<=/imm32/name
30656 0x11/imm32/alloc-id:fake
30657 Single-lit-var/imm32/inouts
30658 0/imm32/no-outputs
30659 0/imm32/no-outputs
30660 0x11/imm32/alloc-id:fake
30661 _string_0f_86_jump_label/imm32/subx-name
30662 0/imm32/no-rm32
30663 0/imm32/no-r32
30664 0/imm32/no-imm32
30665 0/imm32/no-imm8
30666 1/imm32/disp32-is-first-inout
30667 0/imm32/no-xm32
30668 0/imm32/no-x32
30669 0x11/imm32/alloc-id:fake
30670 _Primitive-break-if-addr>-named/imm32/next
30671 _Primitive-break-if-addr>-named:
30672 0x11/imm32/alloc-id:fake:payload
30673 0x11/imm32/alloc-id:fake
30674 _string-break-if-addr>/imm32/name
30675 0x11/imm32/alloc-id:fake
30676 Single-lit-var/imm32/inouts
30677 0/imm32/no-outputs
30678 0/imm32/no-outputs
30679 0x11/imm32/alloc-id:fake
30680 _string_0f_87_jump_label/imm32/subx-name
30681 0/imm32/no-rm32
30682 0/imm32/no-r32
30683 0/imm32/no-imm32
30684 0/imm32/no-imm8
30685 1/imm32/disp32-is-first-inout
30686 0/imm32/no-xm32
30687 0/imm32/no-x32
30688 0x11/imm32/alloc-id:fake
30689 _Primitive-break-if-<-named/imm32/next
30690 _Primitive-break-if-<-named:
30691 0x11/imm32/alloc-id:fake:payload
30692 0x11/imm32/alloc-id:fake
30693 _string-break-if-</imm32/name
30694 0x11/imm32/alloc-id:fake
30695 Single-lit-var/imm32/inouts
30696 0/imm32/no-outputs
30697 0/imm32/no-outputs
30698 0x11/imm32/alloc-id:fake
30699 _string_0f_8c_jump_label/imm32/subx-name
30700 0/imm32/no-rm32
30701 0/imm32/no-r32
30702 0/imm32/no-imm32
30703 0/imm32/no-imm8
30704 1/imm32/disp32-is-first-inout
30705 0/imm32/no-xm32
30706 0/imm32/no-x32
30707 0x11/imm32/alloc-id:fake
30708 _Primitive-break-if->=-named/imm32/next
30709 _Primitive-break-if->=-named:
30710 0x11/imm32/alloc-id:fake:payload
30711 0x11/imm32/alloc-id:fake
30712 _string-break-if->=/imm32/name
30713 0x11/imm32/alloc-id:fake
30714 Single-lit-var/imm32/inouts
30715 0/imm32/no-outputs
30716 0/imm32/no-outputs
30717 0x11/imm32/alloc-id:fake
30718 _string_0f_8d_jump_label/imm32/subx-name
30719 0/imm32/no-rm32
30720 0/imm32/no-r32
30721 0/imm32/no-imm32
30722 0/imm32/no-imm8
30723 1/imm32/disp32-is-first-inout
30724 0/imm32/no-xm32
30725 0/imm32/no-x32
30726 0x11/imm32/alloc-id:fake
30727 _Primitive-break-if-<=-named/imm32/next
30728 _Primitive-break-if-<=-named:
30729 0x11/imm32/alloc-id:fake:payload
30730 0x11/imm32/alloc-id:fake
30731 _string-break-if-<=/imm32/name
30732 0x11/imm32/alloc-id:fake
30733 Single-lit-var/imm32/inouts
30734 0/imm32/no-outputs
30735 0/imm32/no-outputs
30736 0x11/imm32/alloc-id:fake
30737 _string_0f_8e_jump_label/imm32/subx-name
30738 0/imm32/no-rm32
30739 0/imm32/no-r32
30740 0/imm32/no-imm32
30741 0/imm32/no-imm8
30742 1/imm32/disp32-is-first-inout
30743 0/imm32/no-xm32
30744 0/imm32/no-x32
30745 0x11/imm32/alloc-id:fake
30746 _Primitive-break-if->-named/imm32/next
30747 _Primitive-break-if->-named:
30748 0x11/imm32/alloc-id:fake:payload
30749 0x11/imm32/alloc-id:fake
30750 _string-break-if->/imm32/name
30751 0x11/imm32/alloc-id:fake
30752 Single-lit-var/imm32/inouts
30753 0/imm32/no-outputs
30754 0/imm32/no-outputs
30755 0x11/imm32/alloc-id:fake
30756 _string_0f_8f_jump_label/imm32/subx-name
30757 0/imm32/no-rm32
30758 0/imm32/no-r32
30759 0/imm32/no-imm32
30760 0/imm32/no-imm8
30761 1/imm32/disp32-is-first-inout
30762 0/imm32/no-xm32
30763 0/imm32/no-x32
30764 0x11/imm32/alloc-id:fake
30765 _Primitive-break-named/imm32/next
30766 _Primitive-break-named:
30767 0x11/imm32/alloc-id:fake:payload
30768 0x11/imm32/alloc-id:fake
30769 _string-break/imm32/name
30770 0x11/imm32/alloc-id:fake
30771 Single-lit-var/imm32/inouts
30772 0/imm32/no-outputs
30773 0/imm32/no-outputs
30774 0x11/imm32/alloc-id:fake
30775 _string_e9_jump_label/imm32/subx-name
30776 0/imm32/no-rm32
30777 0/imm32/no-r32
30778 0/imm32/no-imm32
30779 0/imm32/no-imm8
30780 1/imm32/disp32-is-first-inout
30781 0/imm32/no-xm32
30782 0/imm32/no-x32
30783 0x11/imm32/alloc-id:fake
30784 _Primitive-loop-if-addr<-named/imm32/next
30785 _Primitive-loop-if-addr<-named:
30786 0x11/imm32/alloc-id:fake:payload
30787 0x11/imm32/alloc-id:fake
30788 _string-loop-if-addr</imm32/name
30789 0x11/imm32/alloc-id:fake
30790 Single-lit-var/imm32/inouts
30791 0/imm32/no-outputs
30792 0/imm32/no-outputs
30793 0x11/imm32/alloc-id:fake
30794 _string_0f_82_jump_label/imm32/subx-name
30795 0/imm32/no-rm32
30796 0/imm32/no-r32
30797 0/imm32/no-imm32
30798 0/imm32/no-imm8
30799 1/imm32/disp32-is-first-inout
30800 0/imm32/no-xm32
30801 0/imm32/no-x32
30802 0x11/imm32/alloc-id:fake
30803 _Primitive-loop-if-addr>=-named/imm32/next
30804 _Primitive-loop-if-addr>=-named:
30805 0x11/imm32/alloc-id:fake:payload
30806 0x11/imm32/alloc-id:fake
30807 _string-loop-if-addr>=/imm32/name
30808 0x11/imm32/alloc-id:fake
30809 Single-lit-var/imm32/inouts
30810 0/imm32/no-outputs
30811 0/imm32/no-outputs
30812 0x11/imm32/alloc-id:fake
30813 _string_0f_83_jump_label/imm32/subx-name
30814 0/imm32/no-rm32
30815 0/imm32/no-r32
30816 0/imm32/no-imm32
30817 0/imm32/no-imm8
30818 1/imm32/disp32-is-first-inout
30819 0/imm32/no-xm32
30820 0/imm32/no-x32
30821 0x11/imm32/alloc-id:fake
30822 _Primitive-loop-if-=-named/imm32/next
30823 _Primitive-loop-if-=-named:
30824 0x11/imm32/alloc-id:fake:payload
30825 0x11/imm32/alloc-id:fake
30826 _string-loop-if-=/imm32/name
30827 0x11/imm32/alloc-id:fake
30828 Single-lit-var/imm32/inouts
30829 0/imm32/no-outputs
30830 0/imm32/no-outputs
30831 0x11/imm32/alloc-id:fake
30832 _string_0f_84_jump_label/imm32/subx-name
30833 0/imm32/no-rm32
30834 0/imm32/no-r32
30835 0/imm32/no-imm32
30836 0/imm32/no-imm8
30837 1/imm32/disp32-is-first-inout
30838 0/imm32/no-xm32
30839 0/imm32/no-x32
30840 0x11/imm32/alloc-id:fake
30841 _Primitive-loop-if-!=-named/imm32/next
30842 _Primitive-loop-if-!=-named:
30843 0x11/imm32/alloc-id:fake:payload
30844 0x11/imm32/alloc-id:fake
30845 _string-loop-if-!=/imm32/name
30846 0x11/imm32/alloc-id:fake
30847 Single-lit-var/imm32/inouts
30848 0/imm32/no-outputs
30849 0/imm32/no-outputs
30850 0x11/imm32/alloc-id:fake
30851 _string_0f_85_jump_label/imm32/subx-name
30852 0/imm32/no-rm32
30853 0/imm32/no-r32
30854 0/imm32/no-imm32
30855 0/imm32/no-imm8
30856 1/imm32/disp32-is-first-inout
30857 0/imm32/no-xm32
30858 0/imm32/no-x32
30859 0x11/imm32/alloc-id:fake
30860 _Primitive-loop-if-addr<=-named/imm32/next
30861 _Primitive-loop-if-addr<=-named:
30862 0x11/imm32/alloc-id:fake:payload
30863 0x11/imm32/alloc-id:fake
30864 _string-loop-if-addr<=/imm32/name
30865 0x11/imm32/alloc-id:fake
30866 Single-lit-var/imm32/inouts
30867 0/imm32/no-outputs
30868 0/imm32/no-outputs
30869 0x11/imm32/alloc-id:fake
30870 _string_0f_86_jump_label/imm32/subx-name
30871 0/imm32/no-rm32
30872 0/imm32/no-r32
30873 0/imm32/no-imm32
30874 0/imm32/no-imm8
30875 1/imm32/disp32-is-first-inout
30876 0/imm32/no-xm32
30877 0/imm32/no-x32
30878 0x11/imm32/alloc-id:fake
30879 _Primitive-loop-if-addr>-named/imm32/next
30880 _Primitive-loop-if-addr>-named:
30881 0x11/imm32/alloc-id:fake:payload
30882 0x11/imm32/alloc-id:fake
30883 _string-loop-if-addr>/imm32/name
30884 0x11/imm32/alloc-id:fake
30885 Single-lit-var/imm32/inouts
30886 0/imm32/no-outputs
30887 0/imm32/no-outputs
30888 0x11/imm32/alloc-id:fake
30889 _string_0f_87_jump_label/imm32/subx-name
30890 0/imm32/no-rm32
30891 0/imm32/no-r32
30892 0/imm32/no-imm32
30893 0/imm32/no-imm8
30894 1/imm32/disp32-is-first-inout
30895 0/imm32/no-xm32
30896 0/imm32/no-x32
30897 0x11/imm32/alloc-id:fake
30898 _Primitive-loop-if-<-named/imm32/next
30899 _Primitive-loop-if-<-named:
30900 0x11/imm32/alloc-id:fake:payload
30901 0x11/imm32/alloc-id:fake
30902 _string-loop-if-</imm32/name
30903 0x11/imm32/alloc-id:fake
30904 Single-lit-var/imm32/inouts
30905 0/imm32/no-outputs
30906 0/imm32/no-outputs
30907 0x11/imm32/alloc-id:fake
30908 _string_0f_8c_jump_label/imm32/subx-name
30909 0/imm32/no-rm32
30910 0/imm32/no-r32
30911 0/imm32/no-imm32
30912 0/imm32/no-imm8
30913 1/imm32/disp32-is-first-inout
30914 0/imm32/no-xm32
30915 0/imm32/no-x32
30916 0x11/imm32/alloc-id:fake
30917 _Primitive-loop-if->=-named/imm32/next
30918 _Primitive-loop-if->=-named:
30919 0x11/imm32/alloc-id:fake:payload
30920 0x11/imm32/alloc-id:fake
30921 _string-loop-if->=/imm32/name
30922 0x11/imm32/alloc-id:fake
30923 Single-lit-var/imm32/inouts
30924 0/imm32/no-outputs
30925 0/imm32/no-outputs
30926 0x11/imm32/alloc-id:fake
30927 _string_0f_8d_jump_label/imm32/subx-name
30928 0/imm32/no-rm32
30929 0/imm32/no-r32
30930 0/imm32/no-imm32
30931 0/imm32/no-imm8
30932 1/imm32/disp32-is-first-inout
30933 0/imm32/no-xm32
30934 0/imm32/no-x32
30935 0x11/imm32/alloc-id:fake
30936 _Primitive-loop-if-<=-named/imm32/next
30937 _Primitive-loop-if-<=-named:
30938 0x11/imm32/alloc-id:fake:payload
30939 0x11/imm32/alloc-id:fake
30940 _string-loop-if-<=/imm32/name
30941 0x11/imm32/alloc-id:fake
30942 Single-lit-var/imm32/inouts
30943 0/imm32/no-outputs
30944 0/imm32/no-outputs
30945 0x11/imm32/alloc-id:fake
30946 _string_0f_8e_jump_label/imm32/subx-name
30947 0/imm32/no-rm32
30948 0/imm32/no-r32
30949 0/imm32/no-imm32
30950 0/imm32/no-imm8
30951 1/imm32/disp32-is-first-inout
30952 0/imm32/no-xm32
30953 0/imm32/no-x32
30954 0x11/imm32/alloc-id:fake
30955 _Primitive-loop-if->-named/imm32/next
30956 _Primitive-loop-if->-named:
30957 0x11/imm32/alloc-id:fake:payload
30958 0x11/imm32/alloc-id:fake
30959 _string-loop-if->/imm32/name
30960 0x11/imm32/alloc-id:fake
30961 Single-lit-var/imm32/inouts
30962 0/imm32/no-outputs
30963 0/imm32/no-outputs
30964 0x11/imm32/alloc-id:fake
30965 _string_0f_8f_jump_label/imm32/subx-name
30966 0/imm32/no-rm32
30967 0/imm32/no-r32
30968 0/imm32/no-imm32
30969 0/imm32/no-imm8
30970 1/imm32/disp32-is-first-inout
30971 0/imm32/no-xm32
30972 0/imm32/no-x32
30973 0x11/imm32/alloc-id:fake
30974 _Primitive-loop-named/imm32/next
30975 _Primitive-loop-named:
30976 0x11/imm32/alloc-id:fake:payload
30977 0x11/imm32/alloc-id:fake
30978 _string-loop/imm32/name
30979 0x11/imm32/alloc-id:fake
30980 Single-lit-var/imm32/inouts
30981 0/imm32/no-outputs
30982 0/imm32/no-outputs
30983 0x11/imm32/alloc-id:fake
30984 _string_e9_jump_label/imm32/subx-name
30985 0/imm32/no-rm32
30986 0/imm32/no-r32
30987 0/imm32/no-imm32
30988 0/imm32/no-imm8
30989 1/imm32/disp32-is-first-inout
30990 0/imm32/no-xm32
30991 0/imm32/no-x32
30992 0x11/imm32/alloc-id:fake
30993 _Primitive-break-if-float</imm32/next
30994
30995 _Primitive-break-if-float<:
30996 0x11/imm32/alloc-id:fake:payload
30997 0x11/imm32/alloc-id:fake
30998 _string-break-if-float</imm32/name
30999 0/imm32/no-inouts
31000 0/imm32/no-inouts
31001 0/imm32/no-outputs
31002 0/imm32/no-outputs
31003 0x11/imm32/alloc-id:fake
31004 _string_0f_82_jump_break/imm32/subx-name
31005 0/imm32/no-rm32
31006 0/imm32/no-r32
31007 0/imm32/no-imm32
31008 0/imm32/no-imm8
31009 0/imm32/no-disp32
31010 0/imm32/no-xm32
31011 0/imm32/no-x32
31012 0x11/imm32/alloc-id:fake
31013 _Primitive-break-if-float>=/imm32/next
31014 _Primitive-break-if-float>=:
31015 0x11/imm32/alloc-id:fake:payload
31016 0x11/imm32/alloc-id:fake
31017 _string-break-if-float>=/imm32/name
31018 0/imm32/no-inouts
31019 0/imm32/no-inouts
31020 0/imm32/no-outputs
31021 0/imm32/no-outputs
31022 0x11/imm32/alloc-id:fake
31023 _string_0f_83_jump_break/imm32/subx-name
31024 0/imm32/no-rm32
31025 0/imm32/no-r32
31026 0/imm32/no-imm32
31027 0/imm32/no-imm8
31028 0/imm32/no-disp32
31029 0/imm32/no-xm32
31030 0/imm32/no-x32
31031 0x11/imm32/alloc-id:fake
31032 _Primitive-break-if-float<=/imm32/next
31033 _Primitive-break-if-float<=:
31034 0x11/imm32/alloc-id:fake:payload
31035 0x11/imm32/alloc-id:fake
31036 _string-break-if-float<=/imm32/name
31037 0/imm32/no-inouts
31038 0/imm32/no-inouts
31039 0/imm32/no-outputs
31040 0/imm32/no-outputs
31041 0x11/imm32/alloc-id:fake
31042 _string_0f_86_jump_break/imm32/subx-name
31043 0/imm32/no-rm32
31044 0/imm32/no-r32
31045 0/imm32/no-imm32
31046 0/imm32/no-imm8
31047 0/imm32/no-disp32
31048 0/imm32/no-xm32
31049 0/imm32/no-x32
31050 0x11/imm32/alloc-id:fake
31051 _Primitive-break-if-float>/imm32/next
31052 _Primitive-break-if-float>:
31053 0x11/imm32/alloc-id:fake:payload
31054 0x11/imm32/alloc-id:fake
31055 _string-break-if-float>/imm32/name
31056 0/imm32/no-inouts
31057 0/imm32/no-inouts
31058 0/imm32/no-outputs
31059 0/imm32/no-outputs
31060 0x11/imm32/alloc-id:fake
31061 _string_0f_87_jump_break/imm32/subx-name
31062 0/imm32/no-rm32
31063 0/imm32/no-r32
31064 0/imm32/no-imm32
31065 0/imm32/no-imm8
31066 0/imm32/no-disp32
31067 0/imm32/no-xm32
31068 0/imm32/no-x32
31069 0x11/imm32/alloc-id:fake
31070 _Primitive-loop-if-float</imm32/next
31071 _Primitive-loop-if-float<:
31072 0x11/imm32/alloc-id:fake:payload
31073 0x11/imm32/alloc-id:fake
31074 _string-loop-if-float</imm32/name
31075 0/imm32/no-inouts
31076 0/imm32/no-inouts
31077 0/imm32/no-outputs
31078 0/imm32/no-outputs
31079 0x11/imm32/alloc-id:fake
31080 _string_0f_82_jump_loop/imm32/subx-name
31081 0/imm32/no-rm32
31082 0/imm32/no-r32
31083 0/imm32/no-imm32
31084 0/imm32/no-imm8
31085 0/imm32/no-disp32
31086 0/imm32/no-xm32
31087 0/imm32/no-x32
31088 0x11/imm32/alloc-id:fake
31089 _Primitive-loop-if-float>=/imm32/next
31090 _Primitive-loop-if-float>=:
31091 0x11/imm32/alloc-id:fake:payload
31092 0x11/imm32/alloc-id:fake
31093 _string-loop-if-float>=/imm32/name
31094 0/imm32/no-inouts
31095 0/imm32/no-inouts
31096 0/imm32/no-outputs
31097 0/imm32/no-outputs
31098 0x11/imm32/alloc-id:fake
31099 _string_0f_83_jump_loop/imm32/subx-name
31100 0/imm32/no-rm32
31101 0/imm32/no-r32
31102 0/imm32/no-imm32
31103 0/imm32/no-imm8
31104 0/imm32/no-disp32
31105 0/imm32/no-xm32
31106 0/imm32/no-x32
31107 0x11/imm32/alloc-id:fake
31108 _Primitive-loop-if-float<=/imm32/next
31109 _Primitive-loop-if-float<=:
31110 0x11/imm32/alloc-id:fake:payload
31111 0x11/imm32/alloc-id:fake
31112 _string-loop-if-float<=/imm32/name
31113 0/imm32/no-inouts
31114 0/imm32/no-inouts
31115 0/imm32/no-outputs
31116 0/imm32/no-outputs
31117 0x11/imm32/alloc-id:fake
31118 _string_0f_86_jump_loop/imm32/subx-name
31119 0/imm32/no-rm32
31120 0/imm32/no-r32
31121 0/imm32/no-imm32
31122 0/imm32/no-imm8
31123 0/imm32/no-disp32
31124 0/imm32/no-xm32
31125 0/imm32/no-x32
31126 0x11/imm32/alloc-id:fake
31127 _Primitive-loop-if-float>/imm32/next
31128 _Primitive-loop-if-float>:
31129 0x11/imm32/alloc-id:fake:payload
31130 0x11/imm32/alloc-id:fake
31131 _string-loop-if-float>/imm32/name
31132 0/imm32/no-inouts
31133 0/imm32/no-inouts
31134 0/imm32/no-outputs
31135 0/imm32/no-outputs
31136 0x11/imm32/alloc-id:fake
31137 _string_0f_87_jump_loop/imm32/subx-name
31138 0/imm32/no-rm32
31139 0/imm32/no-r32
31140 0/imm32/no-imm32
31141 0/imm32/no-imm8
31142 0/imm32/no-disp32
31143 0/imm32/no-xm32
31144 0/imm32/no-x32
31145 0x11/imm32/alloc-id:fake
31146 _Primitive-break-if-float<-named/imm32/next
31147 _Primitive-break-if-float<-named:
31148 0x11/imm32/alloc-id:fake:payload
31149 0x11/imm32/alloc-id:fake
31150 _string-break-if-float</imm32/name
31151 0x11/imm32/alloc-id:fake
31152 Single-lit-var/imm32/inouts
31153 0/imm32/no-outputs
31154 0/imm32/no-outputs
31155 0x11/imm32/alloc-id:fake
31156 _string_0f_82_jump_label/imm32/subx-name
31157 0/imm32/no-rm32
31158 0/imm32/no-r32
31159 0/imm32/no-imm32
31160 0/imm32/no-imm8
31161 1/imm32/disp32-is-first-inout
31162 0/imm32/no-xm32
31163 0/imm32/no-x32
31164 0x11/imm32/alloc-id:fake
31165 _Primitive-break-if-float>=-named/imm32/next
31166 _Primitive-break-if-float>=-named:
31167 0x11/imm32/alloc-id:fake:payload
31168 0x11/imm32/alloc-id:fake
31169 _string-break-if-float>=/imm32/name
31170 0x11/imm32/alloc-id:fake
31171 Single-lit-var/imm32/inouts
31172 0/imm32/no-outputs
31173 0/imm32/no-outputs
31174 0x11/imm32/alloc-id:fake
31175 _string_0f_83_jump_label/imm32/subx-name
31176 0/imm32/no-rm32
31177 0/imm32/no-r32
31178 0/imm32/no-imm32
31179 0/imm32/no-imm8
31180 1/imm32/disp32-is-first-inout
31181 0/imm32/no-xm32
31182 0/imm32/no-x32
31183 0x11/imm32/alloc-id:fake
31184 _Primitive-break-if-float<=-named/imm32/next
31185 _Primitive-break-if-float<=-named:
31186 0x11/imm32/alloc-id:fake:payload
31187 0x11/imm32/alloc-id:fake
31188 _string-break-if-float<=/imm32/name
31189 0x11/imm32/alloc-id:fake
31190 Single-lit-var/imm32/inouts
31191 0/imm32/no-outputs
31192 0/imm32/no-outputs
31193 0x11/imm32/alloc-id:fake
31194 _string_0f_86_jump_label/imm32/subx-name
31195 0/imm32/no-rm32
31196 0/imm32/no-r32
31197 0/imm32/no-imm32
31198 0/imm32/no-imm8
31199 1/imm32/disp32-is-first-inout
31200 0/imm32/no-xm32
31201 0/imm32/no-x32
31202 0x11/imm32/alloc-id:fake
31203 _Primitive-break-if-float>-named/imm32/next
31204 _Primitive-break-if-float>-named:
31205 0x11/imm32/alloc-id:fake:payload
31206 0x11/imm32/alloc-id:fake
31207 _string-break-if-float>/imm32/name
31208 0x11/imm32/alloc-id:fake
31209 Single-lit-var/imm32/inouts
31210 0/imm32/no-outputs
31211 0/imm32/no-outputs
31212 0x11/imm32/alloc-id:fake
31213 _string_0f_87_jump_label/imm32/subx-name
31214 0/imm32/no-rm32
31215 0/imm32/no-r32
31216 0/imm32/no-imm32
31217 0/imm32/no-imm8
31218 1/imm32/disp32-is-first-inout
31219 0/imm32/no-xm32
31220 0/imm32/no-x32
31221 0x11/imm32/alloc-id:fake
31222 _Primitive-loop-if-float<-named/imm32/next
31223 _Primitive-loop-if-float<-named:
31224 0x11/imm32/alloc-id:fake:payload
31225 0x11/imm32/alloc-id:fake
31226 _string-loop-if-float</imm32/name
31227 0x11/imm32/alloc-id:fake
31228 Single-lit-var/imm32/inouts
31229 0/imm32/no-outputs
31230 0/imm32/no-outputs
31231 0x11/imm32/alloc-id:fake
31232 _string_0f_82_jump_label/imm32/subx-name
31233 0/imm32/no-rm32
31234 0/imm32/no-r32
31235 0/imm32/no-imm32
31236 0/imm32/no-imm8
31237 1/imm32/disp32-is-first-inout
31238 0/imm32/no-xm32
31239 0/imm32/no-x32
31240 0x11/imm32/alloc-id:fake
31241 _Primitive-loop-if-float>=-named/imm32/next
31242 _Primitive-loop-if-float>=-named:
31243 0x11/imm32/alloc-id:fake:payload
31244 0x11/imm32/alloc-id:fake
31245 _string-loop-if-float>=/imm32/name
31246 0x11/imm32/alloc-id:fake
31247 Single-lit-var/imm32/inouts
31248 0/imm32/no-outputs
31249 0/imm32/no-outputs
31250 0x11/imm32/alloc-id:fake
31251 _string_0f_83_jump_label/imm32/subx-name
31252 0/imm32/no-rm32
31253 0/imm32/no-r32
31254 0/imm32/no-imm32
31255 0/imm32/no-imm8
31256 1/imm32/disp32-is-first-inout
31257 0/imm32/no-xm32
31258 0/imm32/no-x32
31259 0x11/imm32/alloc-id:fake
31260 _Primitive-loop-if-float<=-named/imm32/next
31261 _Primitive-loop-if-float<=-named:
31262 0x11/imm32/alloc-id:fake:payload
31263 0x11/imm32/alloc-id:fake
31264 _string-loop-if-float<=/imm32/name
31265 0x11/imm32/alloc-id:fake
31266 Single-lit-var/imm32/inouts
31267 0/imm32/no-outputs
31268 0/imm32/no-outputs
31269 0x11/imm32/alloc-id:fake
31270 _string_0f_86_jump_label/imm32/subx-name
31271 0/imm32/no-rm32
31272 0/imm32/no-r32
31273 0/imm32/no-imm32
31274 0/imm32/no-imm8
31275 1/imm32/disp32-is-first-inout
31276 0/imm32/no-xm32
31277 0/imm32/no-x32
31278 0x11/imm32/alloc-id:fake
31279 _Primitive-loop-if-float>-named/imm32/next
31280 _Primitive-loop-if-float>-named:
31281 0x11/imm32/alloc-id:fake:payload
31282 0x11/imm32/alloc-id:fake
31283 _string-loop-if-float>/imm32/name
31284 0x11/imm32/alloc-id:fake
31285 Single-lit-var/imm32/inouts
31286 0/imm32/no-outputs
31287 0/imm32/no-outputs
31288 0x11/imm32/alloc-id:fake
31289 _string_0f_87_jump_label/imm32/subx-name
31290 0/imm32/no-rm32
31291 0/imm32/no-r32
31292 0/imm32/no-imm32
31293 0/imm32/no-imm8
31294 1/imm32/disp32-is-first-inout
31295 0/imm32/no-xm32
31296 0/imm32/no-x32
31297 0/imm32/next
31298 0/imm32/next
31299
31300
31301 _string-add:
31302 0x11/imm32/alloc-id:fake:payload
31303
31304 0x3/imm32/size
31305 0x61/a 0x64/d 0x64/d
31306 _string-address:
31307 0x11/imm32/alloc-id:fake:payload
31308
31309 0x7/imm32/size
31310 0x61/a 0x64/d 0x64/d 0x72/r 0x65/e 0x73/s 0x73/s
31311 _string-add-to:
31312 0x11/imm32/alloc-id:fake:payload
31313
31314 0x6/imm32/size
31315 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o
31316 _string-and:
31317 0x11/imm32/alloc-id:fake:payload
31318
31319 0x3/imm32/size
31320 0x61/a 0x6e/n 0x64/d
31321 _string-and-with:
31322 0x11/imm32/alloc-id:fake:payload
31323
31324 0x8/imm32/size
31325 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h
31326 _string-break:
31327 0x11/imm32/alloc-id:fake:payload
31328
31329 0x5/imm32/size
31330 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k
31331 _string-break-if-<:
31332 0x11/imm32/alloc-id:fake:payload
31333
31334 0xa/imm32/size
31335 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/<
31336 _string-break-if-<=:
31337 0x11/imm32/alloc-id:fake:payload
31338
31339 0xb/imm32/size
31340 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/=
31341 _string-break-if-=:
31342 0x11/imm32/alloc-id:fake:payload
31343
31344 0xa/imm32/size
31345 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/=
31346 _string-break-if->:
31347 0x11/imm32/alloc-id:fake:payload
31348
31349 0xa/imm32/size
31350 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/>
31351 _string-break-if->=:
31352 0x11/imm32/alloc-id:fake:payload
31353
31354 0xb/imm32/size
31355 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/=
31356 _string-break-if-!=:
31357 0x11/imm32/alloc-id:fake:payload
31358
31359 0xb/imm32/size
31360 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/=
31361 _string-break-if-addr<:
31362 0x11/imm32/alloc-id:fake:payload
31363
31364 0xe/imm32/size
31365 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/<
31366 _string-break-if-addr<=:
31367 0x11/imm32/alloc-id:fake:payload
31368
31369 0xf/imm32/size
31370 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/=
31371 _string-break-if-addr>:
31372 0x11/imm32/alloc-id:fake:payload
31373
31374 0xe/imm32/size
31375 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/>
31376 _string-break-if-addr>=:
31377 0x11/imm32/alloc-id:fake:payload
31378
31379 0xf/imm32/size
31380 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/=
31381 _string-break-if-float<:
31382 0x11/imm32/alloc-id:fake:payload
31383
31384 0xf/imm32/size
31385 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3c/<
31386 _string-break-if-float<=:
31387 0x11/imm32/alloc-id:fake:payload
31388
31389 0x10/imm32/size
31390 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3c/< 0x3d/=
31391 _string-break-if-float>:
31392 0x11/imm32/alloc-id:fake:payload
31393
31394 0xf/imm32/size
31395 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3e/>
31396 _string-break-if-float>=:
31397 0x11/imm32/alloc-id:fake:payload
31398
31399 0x10/imm32/size
31400 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3e/> 0x3d/=
31401 _string-compare:
31402 0x11/imm32/alloc-id:fake:payload
31403
31404 0x7/imm32/size
31405 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e
31406 _string-copy:
31407 0x11/imm32/alloc-id:fake:payload
31408
31409 0x4/imm32/size
31410 0x63/c 0x6f/o 0x70/p 0x79/y
31411 _string-copy-to:
31412 0x11/imm32/alloc-id:fake:payload
31413
31414 0x7/imm32/size
31415 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o
31416 _string-copy-byte:
31417 0x11/imm32/alloc-id:fake:payload
31418
31419 0x9/imm32/size
31420 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/- 0x62/b 0x79/y 0x74/t 0x65/e
31421 _string-copy-byte-to:
31422 0x11/imm32/alloc-id:fake:payload
31423
31424 0xc/imm32/size
31425 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/- 0x62/b 0x79/y 0x74/t 0x65/e 0x2d/- 0x74/t 0x6f/o
31426 _string-decrement:
31427 0x11/imm32/alloc-id:fake:payload
31428
31429 0x9/imm32/size
31430 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t
31431 _string-increment:
31432 0x11/imm32/alloc-id:fake:payload
31433
31434 0x9/imm32/size
31435 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t
31436 _string-loop:
31437 0x11/imm32/alloc-id:fake:payload
31438
31439 0x4/imm32/size
31440 0x6c/l 0x6f/o 0x6f/o 0x70/p
31441 _string-loop-if-<:
31442 0x11/imm32/alloc-id:fake:payload
31443
31444 0x9/imm32/size
31445 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/<
31446 _string-loop-if-<=:
31447 0x11/imm32/alloc-id:fake:payload
31448
31449 0xa/imm32/size
31450 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/=
31451 _string-loop-if-=:
31452 0x11/imm32/alloc-id:fake:payload
31453
31454 0x9/imm32/size
31455 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/=
31456 _string-loop-if->:
31457 0x11/imm32/alloc-id:fake:payload
31458
31459 0x9/imm32/size
31460 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/>
31461 _string-loop-if->=:
31462 0x11/imm32/alloc-id:fake:payload
31463
31464 0xa/imm32/size
31465 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/=
31466 _string-loop-if-!=:
31467 0x11/imm32/alloc-id:fake:payload
31468
31469 0xa/imm32/size
31470 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/=
31471 _string-loop-if-addr<:
31472 0x11/imm32/alloc-id:fake:payload
31473
31474 0xd/imm32/size
31475 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/<
31476 _string-loop-if-addr<=:
31477 0x11/imm32/alloc-id:fake:payload
31478
31479 0xe/imm32/size
31480 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/=
31481 _string-loop-if-addr>:
31482 0x11/imm32/alloc-id:fake:payload
31483
31484 0xd/imm32/size
31485 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/>
31486 _string-loop-if-addr>=:
31487 0x11/imm32/alloc-id:fake:payload
31488
31489 0xe/imm32/size
31490 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/=
31491 _string-loop-if-float<:
31492 0x11/imm32/alloc-id:fake:payload
31493
31494 0xe/imm32/size
31495 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3c/<
31496 _string-loop-if-float<=:
31497 0x11/imm32/alloc-id:fake:payload
31498
31499 0xf/imm32/size
31500 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3c/< 0x3d/=
31501 _string-loop-if-float>:
31502 0x11/imm32/alloc-id:fake:payload
31503
31504 0xe/imm32/size
31505 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3e/>
31506 _string-loop-if-float>=:
31507 0x11/imm32/alloc-id:fake:payload
31508
31509 0xf/imm32/size
31510 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3e/> 0x3d/=
31511 _string-multiply:
31512 0x11/imm32/alloc-id:fake:payload
31513
31514 0x8/imm32/size
31515 0x6d/m 0x75/u 0x6c/l 0x74/t 0x69/i 0x70/p 0x6c/l 0x79/y
31516 _string-convert:
31517 0x11/imm32/alloc-id:fake:payload
31518
31519 0x7/imm32/size
31520 0x63/c 0x6f/o 0x6e/n 0x76/v 0x65/e 0x72/r 0x74/t
31521 _string-truncate:
31522 0x11/imm32/alloc-id:fake:payload
31523
31524 0x8/imm32/size
31525 0x74/t 0x72/r 0x75/u 0x6e/n 0x63/c 0x61/a 0x74/t 0x65/e
31526 _string-reinterpret:
31527 0x11/imm32/alloc-id:fake:payload
31528
31529 0xb/imm32/size
31530 0x72/r 0x65/e 0x69/i 0x6e/n 0x74/t 0x65/e 0x72/r 0x70/p 0x72/r 0x65/e 0x74/t
31531 _string-divide:
31532 0x11/imm32/alloc-id:fake:payload
31533
31534 0x6/imm32/size
31535 0x64/d 0x69/i 0x76/v 0x69/i 0x64/d 0x65/e
31536 _string-max:
31537 0x11/imm32/alloc-id:fake:payload
31538
31539 0x3/imm32/size
31540 0x6d/m 0x61/a 0x78/x
31541 _string-min:
31542 0x11/imm32/alloc-id:fake:payload
31543
31544 0x3/imm32/size
31545 0x6d/m 0x69/i 0x6e/n
31546 _string-reciprocal:
31547 0x11/imm32/alloc-id:fake:payload
31548
31549 0xa/imm32/size
31550 0x72/r 0x65/e 0x63/c 0x69/i 0x70/p 0x72/r 0x6f/o 0x63/c 0x61/a 0x6c/l
31551 _string-square-root:
31552 0x11/imm32/alloc-id:fake:payload
31553
31554 0xb/imm32/size
31555 0x73/s 0x71/q 0x75/u 0x61/a 0x72/r 0x65/e 0x2d/- 0x72/r 0x6f/o 0x6f/o 0x74/t
31556 _string-inverse-square-root:
31557 0x11/imm32/alloc-id:fake:payload
31558
31559 0x13/imm32/size
31560 0x69/i 0x6e/n 0x76/v 0x65/e 0x72/r 0x73/s 0x65/e 0x2d/- 0x73/s 0x71/q 0x75/u 0x61/a 0x72/r 0x65/e 0x2d/- 0x72/r 0x6f/o 0x6f/o 0x74/t
31561 _string-negate:
31562 0x11/imm32/alloc-id:fake:payload
31563
31564 0x6/imm32/size
31565 0x6e/n 0x65/e 0x67/g 0x61/a 0x74/t 0x65/e
31566 _string-or:
31567 0x11/imm32/alloc-id:fake:payload
31568
31569 0x2/imm32/size
31570 0x6f/o 0x72/r
31571 _string-or-with:
31572 0x11/imm32/alloc-id:fake:payload
31573
31574 0x7/imm32/size
31575 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h
31576 _string-subtract:
31577 0x11/imm32/alloc-id:fake:payload
31578
31579 0x8/imm32/size
31580 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t
31581 _string-subtract-from:
31582 0x11/imm32/alloc-id:fake:payload
31583
31584 0xd/imm32/size
31585 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t 0x2d/dash 0x66/f 0x72/r 0x6f/o 0x6d/m
31586 _string-xor:
31587 0x11/imm32/alloc-id:fake:payload
31588
31589 0x3/imm32/size
31590 0x78/x 0x6f/o 0x72/r
31591 _string-xor-with:
31592 0x11/imm32/alloc-id:fake:payload
31593
31594 0x8/imm32/size
31595 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h
31596 _string-shift-left:
31597 0x11/imm32/alloc-id:fake:payload
31598
31599 0xa/imm32/size
31600 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x6c/l 0x65/e 0x66/f 0x74/t
31601 _string-shift-right:
31602 0x11/imm32/alloc-id:fake:payload
31603
31604 0xb/imm32/size
31605 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t
31606 _string-shift-right-signed:
31607 0x11/imm32/alloc-id:fake:payload
31608
31609 0x12/imm32/size
31610 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x73/s 0x69/i 0x67/g 0x6e/n 0x65/e 0x64/d
31611
31612
31613 _string_01_add_to:
31614 0x11/imm32/alloc-id:fake:payload
31615
31616 0x9/imm32/size
31617 0x30/0 0x31/1 0x2f/slash 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o
31618 _string_03_add:
31619 0x11/imm32/alloc-id:fake:payload
31620
31621 0x6/imm32/size
31622 0x30/0 0x33/3 0x2f/slash 0x61/a 0x64/d 0x64/d
31623 _string_05_add_to_eax:
31624 0x11/imm32/alloc-id:fake:payload
31625
31626 0xd/imm32/size
31627 0x30/0 0x35/5 0x2f/slash 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x61/a 0x78/x
31628 _string_09_or_with:
31629 0x11/imm32/alloc-id:fake:payload
31630
31631 0xa/imm32/size
31632 0x30/0 0x39/9 0x2f/slash 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h
31633 _string_0b_or:
31634 0x11/imm32/alloc-id:fake:payload
31635
31636 0x5/imm32/size
31637 0x30/0 0x62/b 0x2f/slash 0x6f/o 0x72/r
31638 _string_0d_or_with_eax:
31639 0x11/imm32/alloc-id:fake:payload
31640
31641 0xe/imm32/size
31642 0x30/0 0x64/d 0x2f/slash 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h 0x2d/dash 0x65/e 0x61/a 0x78/x
31643 _string_0f_82_jump_label:
31644 0x11/imm32/alloc-id:fake:payload
31645
31646 0x13/imm32/size
31647 0x30/0 0x66/f 0x20/space 0x38/8 0x32/2 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/<
31648 _string_0f_82_jump_break:
31649 0x11/imm32/alloc-id:fake:payload
31650
31651 0x20/imm32/size
31652 0x30/0 0x66/f 0x20/space 0x38/8 0x32/2 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31653 _string_0f_82_jump_loop:
31654 0x11/imm32/alloc-id:fake:payload
31655
31656 0x1f/imm32/size
31657 0x30/0 0x66/f 0x20/space 0x38/8 0x32/2 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31658 _string_0f_83_jump_label:
31659 0x11/imm32/alloc-id:fake:payload
31660
31661 0x14/imm32/size
31662 0x30/0 0x66/f 0x20/space 0x38/8 0x33/3 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/=
31663 _string_0f_83_jump_break:
31664 0x11/imm32/alloc-id:fake:payload
31665
31666 0x21/imm32/size
31667 0x30/0 0x66/f 0x20/space 0x38/8 0x33/3 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31668 _string_0f_83_jump_loop:
31669 0x11/imm32/alloc-id:fake:payload
31670
31671 0x20/imm32/size
31672 0x30/0 0x66/f 0x20/space 0x38/8 0x33/3 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31673 _string_0f_84_jump_label:
31674 0x11/imm32/alloc-id:fake:payload
31675
31676 0xf/imm32/size
31677 0x30/0 0x66/f 0x20/space 0x38/8 0x34/4 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/=
31678 _string_0f_84_jump_break:
31679 0x11/imm32/alloc-id:fake:payload
31680
31681 0x1c/imm32/size
31682 0x30/0 0x66/f 0x20/space 0x38/8 0x34/4 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31683 _string_0f_84_jump_loop:
31684 0x11/imm32/alloc-id:fake:payload
31685
31686 0x1b/imm32/size
31687 0x30/0 0x66/f 0x20/space 0x38/8 0x34/4 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31688 _string_0f_85_jump_label:
31689 0x11/imm32/alloc-id:fake:payload
31690
31691 0x10/imm32/size
31692 0x30/0 0x66/f 0x20/space 0x38/8 0x35/5 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/=
31693 _string_0f_85_jump_break:
31694 0x11/imm32/alloc-id:fake:payload
31695
31696 0x1d/imm32/size
31697 0x30/0 0x66/f 0x20/space 0x38/8 0x35/5 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31698 _string_0f_85_jump_loop:
31699 0x11/imm32/alloc-id:fake:payload
31700
31701 0x1c/imm32/size
31702 0x30/0 0x66/f 0x20/space 0x38/8 0x35/5 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31703 _string_0f_86_jump_label:
31704 0x11/imm32/alloc-id:fake:payload
31705
31706 0x14/imm32/size
31707 0x30/0 0x66/f 0x20/space 0x38/8 0x36/6 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/=
31708 _string_0f_86_jump_break:
31709 0x11/imm32/alloc-id:fake:payload
31710
31711 0x21/imm32/size
31712 0x30/0 0x66/f 0x20/space 0x38/8 0x36/6 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31713 _string_0f_86_jump_loop:
31714 0x11/imm32/alloc-id:fake:payload
31715
31716 0x20/imm32/size
31717 0x30/0 0x66/f 0x20/space 0x38/8 0x36/6 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31718 _string_0f_87_jump_label:
31719 0x11/imm32/alloc-id:fake:payload
31720
31721 0x13/imm32/size
31722 0x30/0 0x66/f 0x20/space 0x38/8 0x37/7 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/>
31723 _string_0f_87_jump_break:
31724 0x11/imm32/alloc-id:fake:payload
31725
31726 0x20/imm32/size
31727 0x30/0 0x66/f 0x20/space 0x38/8 0x37/7 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31728 _string_0f_87_jump_loop:
31729 0x11/imm32/alloc-id:fake:payload
31730
31731 0x1f/imm32/size
31732 0x30/0 0x66/f 0x20/space 0x38/8 0x37/7 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31733 _string_0f_8c_jump_label:
31734 0x11/imm32/alloc-id:fake:payload
31735
31736 0xf/imm32/size
31737 0x30/0 0x66/f 0x20/space 0x38/8 0x63/c 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/<
31738 _string_0f_8c_jump_break:
31739 0x11/imm32/alloc-id:fake:payload
31740
31741 0x1c/imm32/size
31742 0x30/0 0x66/f 0x20/space 0x38/8 0x63/c 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31743 _string_0f_8c_jump_loop:
31744 0x11/imm32/alloc-id:fake:payload
31745
31746 0x1b/imm32/size
31747 0x30/0 0x66/f 0x20/space 0x38/8 0x63/c 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31748 _string_0f_8d_jump_label:
31749 0x11/imm32/alloc-id:fake:payload
31750
31751 0x10/imm32/size
31752 0x30/0 0x66/f 0x20/space 0x38/8 0x64/d 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/=
31753 _string_0f_8d_jump_break:
31754 0x11/imm32/alloc-id:fake:payload
31755
31756 0x1d/imm32/size
31757 0x30/0 0x66/f 0x20/space 0x38/8 0x64/d 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31758 _string_0f_8d_jump_loop:
31759 0x11/imm32/alloc-id:fake:payload
31760
31761 0x1c/imm32/size
31762 0x30/0 0x66/f 0x20/space 0x38/8 0x64/d 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31763 _string_0f_8e_jump_label:
31764 0x11/imm32/alloc-id:fake:payload
31765
31766 0x10/imm32/size
31767 0x30/0 0x66/f 0x20/space 0x38/8 0x65/e 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/=
31768 _string_0f_8e_jump_break:
31769 0x11/imm32/alloc-id:fake:payload
31770
31771 0x1d/imm32/size
31772 0x30/0 0x66/f 0x20/space 0x38/8 0x65/e 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31773 _string_0f_8e_jump_loop:
31774 0x11/imm32/alloc-id:fake:payload
31775
31776 0x1c/imm32/size
31777 0x30/0 0x66/f 0x20/space 0x38/8 0x65/e 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31778 _string_0f_8f_jump_label:
31779 0x11/imm32/alloc-id:fake:payload
31780
31781 0xf/imm32/size
31782 0x30/0 0x66/f 0x20/space 0x38/8 0x66/f 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/>
31783 _string_0f_8f_jump_break:
31784 0x11/imm32/alloc-id:fake:payload
31785
31786 0x1c/imm32/size
31787 0x30/0 0x66/f 0x20/space 0x38/8 0x66/f 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31788 _string_0f_8f_jump_loop:
31789 0x11/imm32/alloc-id:fake:payload
31790
31791 0x1b/imm32/size
31792 0x30/0 0x66/f 0x20/space 0x38/8 0x66/f 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
31793 _string_0f_af_multiply:
31794 0x11/imm32/alloc-id:fake:payload
31795
31796 0xe/imm32/size
31797 0x30/0 0x66/f 0x20/space 0x61/a 0x66/f 0x2f/slash 0x6d/m 0x75/u 0x6c/l 0x74/t 0x69/i 0x70/p 0x6c/l 0x79/y
31798 _string_f3_0f_2a_convert_to_float:
31799 0x11/imm32/alloc-id:fake:payload
31800
31801 0x19/imm32/size
31802 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x32/2 0x61/a 0x2f/slash 0x63/c 0x6f/o 0x6e/n 0x76/v 0x65/e 0x72/r 0x74/t 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t
31803 _string_f3_0f_2d_convert_to_int:
31804 0x11/imm32/alloc-id:fake:payload
31805
31806 0x17/imm32/size
31807 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x32/2 0x64/d 0x2f/slash 0x63/c 0x6f/o 0x6e/n 0x76/v 0x65/e 0x72/r 0x74/t 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x69/i 0x6e/n 0x74/t
31808 _string_f3_0f_2c_truncate_to_int:
31809 0x11/imm32/alloc-id:fake:payload
31810
31811 0x18/imm32/size
31812 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x32/2 0x63/c 0x2f/slash 0x74/t 0x72/r 0x75/u 0x6e/n 0x63/c 0x61/a 0x74/t 0x65/e 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x69/i 0x6e/n 0x74/t
31813 _string_f3_0f_58_add:
31814 0x11/imm32/alloc-id:fake:payload
31815
31816 0xc/imm32/size
31817 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x38/8 0x2f/slash 0x61/a 0x64/d 0x64/d
31818 _string_f3_0f_5c_subtract:
31819 0x11/imm32/alloc-id:fake:payload
31820
31821 0x11/imm32/size
31822 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x63/c 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t
31823 _string_f3_0f_59_multiply:
31824 0x11/imm32/alloc-id:fake:payload
31825
31826 0x11/imm32/size
31827 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x39/9 0x2f/slash 0x6d/m 0x75/u 0x6c/l 0x74/t 0x69/i 0x70/p 0x6c/l 0x79/y
31828 _string_f3_0f_5e_divide:
31829 0x11/imm32/alloc-id:fake:payload
31830
31831 0xf/imm32/size
31832 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x65/e 0x2f/slash 0x64/d 0x69/i 0x76/v 0x69/i 0x64/d 0x65/e
31833 _string_f3_0f_53_reciprocal:
31834 0x11/imm32/alloc-id:fake:payload
31835
31836 0x13/imm32/size
31837 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x33/3 0x2f/slash 0x72/r 0x65/e 0x63/c 0x69/i 0x70/p 0x72/r 0x6f/o 0x63/c 0x61/a 0x6c/l
31838 _string_f3_0f_51_square_root:
31839 0x11/imm32/alloc-id:fake:payload
31840
31841 0x14/imm32/size
31842 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x31/1 0x2f/slash 0x73/s 0x71/q 0x75/u 0x61/a 0x72/r 0x65/e 0x2d/dash 0x72/r 0x6f/o 0x6f/o 0x74/t
31843 _string_f3_0f_52_inverse_square_root:
31844 0x11/imm32/alloc-id:fake:payload
31845
31846 0x1c/imm32/size
31847 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x32/2 0x2f/slash 0x69/i 0x6e/n 0x76/v 0x65/e 0x72/r 0x73/s 0x65/e 0x2d/dash 0x73/s 0x71/q 0x75/u 0x61/a 0x72/r 0x65/e 0x2d/dash 0x72/r 0x6f/o 0x6f/o 0x74/t
31848 _string_f3_0f_5d_min:
31849 0x11/imm32/alloc-id:fake:payload
31850
31851 0xc/imm32/size
31852 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x64/d 0x2f/slash 0x6d/m 0x69/i 0x6e/n
31853 _string_f3_0f_5f_max:
31854 0x11/imm32/alloc-id:fake:payload
31855
31856 0xc/imm32/size
31857 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x66/f 0x2f/slash 0x6d/m 0x61/a 0x78/x
31858 _string_f3_0f_10_copy:
31859 0x11/imm32/alloc-id:fake:payload
31860
31861 0xd/imm32/size
31862 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x31/1 0x30/0 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y
31863 _string_f3_0f_11_copy:
31864 0x11/imm32/alloc-id:fake:payload
31865
31866 0xd/imm32/size
31867 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x31/1 0x31/1 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y
31868 _string_0f_2f_compare:
31869 0x11/imm32/alloc-id:fake:payload
31870
31871 0xd/imm32/size
31872 0x30/0 0x66/f 0x20/space 0x32/2 0x66/f 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e
31873 _string_21_and_with:
31874 0x11/imm32/alloc-id:fake:payload
31875
31876 0xb/imm32/size
31877 0x32/2 0x31/1 0x2f/slash 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h
31878 _string_23_and:
31879 0x11/imm32/alloc-id:fake:payload
31880
31881 0x6/imm32/size
31882 0x32/2 0x33/3 0x2f/slash 0x61/a 0x6e/n 0x64/d
31883 _string_25_and_with_eax:
31884 0x11/imm32/alloc-id:fake:payload
31885
31886 0xf/imm32/size
31887 0x32/2 0x35/5 0x2f/slash 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h 0x2d/dash 0x65/e 0x61/a 0x78/x
31888 _string_29_subtract_from:
31889 0x11/imm32/alloc-id:fake:payload
31890
31891 0x10/imm32/size
31892 0x32/2 0x39/9 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t 0x2d/dash 0x66/f 0x72/r 0x6f/o 0x6d/m
31893 _string_2b_subtract:
31894 0x11/imm32/alloc-id:fake:payload
31895
31896 0xb/imm32/size
31897 0x32/2 0x62/b 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t
31898 _string_2d_subtract_from_eax:
31899 0x11/imm32/alloc-id:fake:payload
31900
31901 0x14/imm32/size
31902 0x32/2 0x64/d 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t 0x2d/dash 0x66/f 0x72/r 0x6f/o 0x6d/m 0x2d/dash 0x65/e 0x61/a 0x78/x
31903 _string_31_xor_with:
31904 0x11/imm32/alloc-id:fake:payload
31905
31906 0xb/imm32/size
31907 0x33/3 0x31/1 0x2f/slash 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h
31908 _string_33_xor:
31909 0x11/imm32/alloc-id:fake:payload
31910
31911 0x6/imm32/size
31912 0x33/3 0x33/3 0x2f/slash 0x78/x 0x6f/o 0x72/r
31913 _string_35_xor_with_eax:
31914 0x11/imm32/alloc-id:fake:payload
31915
31916 0xf/imm32/size
31917 0x33/3 0x35/5 0x2f/slash 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h 0x2d/dash 0x65/e 0x61/a 0x78/x
31918 _string_39_compare->:
31919 0x11/imm32/alloc-id:fake:payload
31920
31921 0xc/imm32/size
31922 0x33/3 0x39/9 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x2d/dash 0x3e/>
31923 _string_3b_compare<-:
31924 0x11/imm32/alloc-id:fake:payload
31925
31926 0xc/imm32/size
31927 0x33/3 0x62/b 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x3c/< 0x2d/dash
31928 _string_3d_compare_eax_with:
31929 0x11/imm32/alloc-id:fake:payload
31930
31931 0x13/imm32/size
31932 0x33/3 0x64/d 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x2d/dash 0x65/e 0x61/a 0x78/x 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h
31933 _string_40_increment_eax:
31934 0x11/imm32/alloc-id:fake:payload
31935
31936 0x10/imm32/size
31937 0x34/4 0x30/0 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x61/a 0x78/x
31938 _string_41_increment_ecx:
31939 0x11/imm32/alloc-id:fake:payload
31940
31941 0x10/imm32/size
31942 0x34/4 0x31/1 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x63/c 0x78/x
31943 _string_42_increment_edx:
31944 0x11/imm32/alloc-id:fake:payload
31945
31946 0x10/imm32/size
31947 0x34/4 0x32/2 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x64/d 0x78/x
31948 _string_43_increment_ebx:
31949 0x11/imm32/alloc-id:fake:payload
31950
31951 0x10/imm32/size
31952 0x34/4 0x33/3 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x62/b 0x78/x
31953 _string_46_increment_esi:
31954 0x11/imm32/alloc-id:fake:payload
31955
31956 0x10/imm32/size
31957 0x34/4 0x36/6 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x73/s 0x69/i
31958 _string_47_increment_edi:
31959 0x11/imm32/alloc-id:fake:payload
31960
31961 0x10/imm32/size
31962 0x34/4 0x37/7 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x64/d 0x69/i
31963 _string_48_decrement_eax:
31964 0x11/imm32/alloc-id:fake:payload
31965
31966 0x10/imm32/size
31967 0x34/4 0x38/8 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x61/a 0x78/x
31968 _string_49_decrement_ecx:
31969 0x11/imm32/alloc-id:fake:payload
31970
31971 0x10/imm32/size
31972 0x34/4 0x39/9 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x63/c 0x78/x
31973 _string_4a_decrement_edx:
31974 0x11/imm32/alloc-id:fake:payload
31975
31976 0x10/imm32/size
31977 0x34/4 0x61/a 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x64/d 0x78/x
31978 _string_4b_decrement_ebx:
31979 0x11/imm32/alloc-id:fake:payload
31980
31981 0x10/imm32/size
31982 0x34/4 0x62/b 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x62/b 0x78/x
31983 _string_4e_decrement_esi:
31984 0x11/imm32/alloc-id:fake:payload
31985
31986 0x10/imm32/size
31987 0x34/4 0x65/e 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x73/s 0x69/i
31988 _string_4f_decrement_edi:
31989 0x11/imm32/alloc-id:fake:payload
31990
31991 0x10/imm32/size
31992 0x34/4 0x66/f 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x64/d 0x69/i
31993 _string_81_subop_add:
31994 0x11/imm32/alloc-id:fake:payload
31995
31996 0xe/imm32/size
31997 0x38/8 0x31/1 0x20/space 0x30/0 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x61/a 0x64/d 0x64/d
31998 _string_81_subop_or:
31999 0x11/imm32/alloc-id:fake:payload
32000
32001 0xd/imm32/size
32002 0x38/8 0x31/1 0x20/space 0x31/1 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x6f/o 0x72/r
32003 _string_81_subop_and:
32004 0x11/imm32/alloc-id:fake:payload
32005
32006 0xe/imm32/size
32007 0x38/8 0x31/1 0x20/space 0x34/4 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x61/a 0x6e/n 0x64/d
32008 _string_81_subop_subtract:
32009 0x11/imm32/alloc-id:fake:payload
32010
32011 0x13/imm32/size
32012 0x38/8 0x31/1 0x20/space 0x35/5 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t
32013 _string_81_subop_xor:
32014 0x11/imm32/alloc-id:fake:payload
32015
32016 0xe/imm32/size
32017 0x38/8 0x31/1 0x20/space 0x36/6 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x78/x 0x6f/o 0x72/r
32018 _string_81_subop_compare:
32019 0x11/imm32/alloc-id:fake:payload
32020
32021 0x12/imm32/size
32022 0x38/8 0x31/1 0x20/space 0x37/7 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e
32023 _string_89_<-:
32024 0x11/imm32/alloc-id:fake:payload
32025
32026 0x5/imm32/size
32027 0x38/8 0x39/9 0x2f/slash 0x3c/< 0x2d/dash
32028 _string_8b_->:
32029 0x11/imm32/alloc-id:fake:payload
32030
32031 0x5/imm32/size
32032 0x38/8 0x62/b 0x2f/slash 0x2d/dash 0x3e/>
32033 _string_8a_copy_byte:
32034 0x11/imm32/alloc-id:fake:payload
32035
32036 0x9/imm32/size
32037 0x38/8 0x61/a 0x2f// 0x62/b 0x79/y 0x74/t 0x65/e 0x2d/- 0x3e/>
32038 _string_88_copy_byte:
32039 0x11/imm32/alloc-id:fake:payload
32040
32041 0x9/imm32/size
32042 0x38/8 0x38/8 0x2f// 0x62/b 0x79/y 0x74/t 0x65/e 0x3c/< 0x2d/-
32043 _string_8d_copy_address:
32044 0x11/imm32/alloc-id:fake:payload
32045
32046 0xf/imm32/size
32047 0x38/8 0x64/d 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x65/e 0x73/s 0x73/s
32048 _string_b8_copy_to_eax:
32049 0x11/imm32/alloc-id:fake:payload
32050
32051 0xe/imm32/size
32052 0x62/b 0x38/8 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x61/a 0x78/x
32053 _string_b9_copy_to_ecx:
32054 0x11/imm32/alloc-id:fake:payload
32055
32056 0xe/imm32/size
32057 0x62/b 0x39/9 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x63/c 0x78/x
32058 _string_ba_copy_to_edx:
32059 0x11/imm32/alloc-id:fake:payload
32060
32061 0xe/imm32/size
32062 0x62/b 0x61/a 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x64/d 0x78/x
32063 _string_bb_copy_to_ebx:
32064 0x11/imm32/alloc-id:fake:payload
32065
32066 0xe/imm32/size
32067 0x62/b 0x62/b 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x62/b 0x78/x
32068 _string_be_copy_to_esi:
32069 0x11/imm32/alloc-id:fake:payload
32070
32071 0xe/imm32/size
32072 0x62/b 0x65/e 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x73/s 0x69/i
32073 _string_bf_copy_to_edi:
32074 0x11/imm32/alloc-id:fake:payload
32075
32076 0xe/imm32/size
32077 0x62/b 0x66/f 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x64/d 0x69/i
32078 _string_c7_subop_copy:
32079 0x11/imm32/alloc-id:fake:payload
32080
32081 0xf/imm32/size
32082 0x63/c 0x37/7 0x20/space 0x30/0 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y
32083 _string_e9_jump_label:
32084 0x11/imm32/alloc-id:fake:payload
32085
32086 0x7/imm32/size
32087 0x65/e 0x39/9 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p
32088 _string_e9_jump_break:
32089 0x11/imm32/alloc-id:fake:payload
32090
32091 0x14/imm32/size
32092 0x65/e 0x39/9 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
32093 _string_e9_jump_loop:
32094 0x11/imm32/alloc-id:fake:payload
32095
32096 0x13/imm32/size
32097 0x65/e 0x39/9 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2
32098 _string_f7_subop_negate:
32099 0x11/imm32/alloc-id:fake:payload
32100
32101 0x11/imm32/size
32102 0x66/f 0x37/7 0x20/space 0x33/3 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x6e/n 0x65/e 0x67/g 0x61/a 0x74/t 0x65/e
32103 _string_ff_subop_increment:
32104 0x11/imm32/alloc-id:fake:payload
32105
32106 0x14/imm32/size
32107 0x66/f 0x66/f 0x20/space 0x30/0 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t
32108 _string_ff_subop_decrement:
32109 0x11/imm32/alloc-id:fake:payload
32110
32111 0x14/imm32/size
32112 0x66/f 0x66/f 0x20/space 0x31/1 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t
32113 _string_c1_subop_shift_left:
32114 0x11/imm32/alloc-id:fake:payload
32115
32116 0x15/imm32/size
32117 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x34/4 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x6c/l 0x65/e 0x66/f 0x74/t
32118 _string_c1_subop_shift_right_padding_zeroes:
32119 0x11/imm32/alloc-id:fake:payload
32120
32121 0x25/imm32/size
32122 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x35/5 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x70/p 0x61/a 0x64/d 0x64/d 0x69/i 0x6e/n 0x67/g 0x2d/dash 0x7a/z 0x65/e 0x72/r 0x6f/o 0x65/e 0x73/s
32123 _string_c1_subop_shift_right_preserving_sign:
32124 0x11/imm32/alloc-id:fake:payload
32125
32126 0x26/imm32/size
32127 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x37/7 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x70/p 0x72/r 0x65/e 0x73/s 0x65/e 0x72/r 0x76/v 0x69/i 0x6e/n 0x67/g 0x2d/dash 0x73/s 0x69/i 0x67/g 0x6e/n
32128
32129 Single-int-var-in-mem:
32130 0x11/imm32/alloc-id:fake:payload
32131 0x11/imm32/alloc-id:fake
32132 Int-var-in-mem/imm32
32133 0/imm32/next
32134 0/imm32/next
32135
32136 Int-var-in-mem:
32137 0x11/imm32/alloc-id:fake:payload
32138 0/imm32/name
32139 0/imm32/name
32140 0x11/imm32/alloc-id:fake
32141 Type-int/imm32
32142 1/imm32/some-block-depth
32143 1/imm32/some-stack-offset
32144 0/imm32/no-register
32145 0/imm32/no-register
32146
32147
32148 Single-byte-var-in-mem:
32149 0x11/imm32/alloc-id:fake:payload
32150 0x11/imm32/alloc-id:fake
32151 Byte-var-in-mem/imm32
32152 0/imm32/next
32153 0/imm32/next
32154
32155
32156 Byte-var-in-mem:
32157 0x11/imm32/alloc-id:fake:payload
32158 0/imm32/name
32159 0/imm32/name
32160 0x11/imm32/alloc-id:fake
32161 Type-byte/imm32
32162 1/imm32/some-block-depth
32163 1/imm32/some-stack-offset
32164 0/imm32/no-register
32165 0/imm32/no-register
32166
32167 Two-args-int-stack-int-reg:
32168 0x11/imm32/alloc-id:fake:payload
32169 0x11/imm32/alloc-id:fake
32170 Int-var-in-mem/imm32
32171 0x11/imm32/alloc-id:fake
32172 Single-int-var-in-some-register/imm32/next
32173
32174 Two-int-args-in-regs:
32175 0x11/imm32/alloc-id:fake:payload
32176 0x11/imm32/alloc-id:fake
32177 Int-var-in-some-register/imm32
32178 0x11/imm32/alloc-id:fake
32179 Single-int-var-in-some-register/imm32/next
32180
32181
32182 Two-args-byte-stack-byte-reg:
32183 0x11/imm32/alloc-id:fake:payload
32184 0x11/imm32/alloc-id:fake
32185 Byte-var-in-mem/imm32
32186 0x11/imm32/alloc-id:fake
32187 Single-byte-var-in-some-register/imm32/next
32188
32189 Two-args-int-reg-int-stack:
32190 0x11/imm32/alloc-id:fake:payload
32191 0x11/imm32/alloc-id:fake
32192 Int-var-in-some-register/imm32
32193 0x11/imm32/alloc-id:fake
32194 Single-int-var-in-mem/imm32/next
32195
32196 Two-args-int-eax-int-literal:
32197 0x11/imm32/alloc-id:fake:payload
32198 0x11/imm32/alloc-id:fake
32199 Int-var-in-eax/imm32
32200 0x11/imm32/alloc-id:fake
32201 Single-lit-var/imm32/next
32202
32203 Int-var-and-literal:
32204 0x11/imm32/alloc-id:fake:payload
32205 0x11/imm32/alloc-id:fake
32206 Int-var-in-mem/imm32
32207 0x11/imm32/alloc-id:fake
32208 Single-lit-var/imm32/next
32209
32210 Int-var-in-register-and-literal:
32211 0x11/imm32/alloc-id:fake:payload
32212 0x11/imm32/alloc-id:fake
32213 Int-var-in-some-register/imm32
32214 0x11/imm32/alloc-id:fake
32215 Single-lit-var/imm32/next
32216
32217 Two-float-args-in-regs:
32218 0x11/imm32/alloc-id:fake:payload
32219 0x11/imm32/alloc-id:fake
32220 Float-var-in-some-register/imm32
32221 0x11/imm32/alloc-id:fake
32222 Single-float-var-in-some-register/imm32/next
32223
32224 Two-args-float-reg-float-stack:
32225 0x11/imm32/alloc-id:fake:payload
32226 0x11/imm32/alloc-id:fake
32227 Float-var-in-some-register/imm32
32228 0x11/imm32/alloc-id:fake
32229 Single-float-var-in-mem/imm32/next
32230
32231 Two-args-float-stack-float-reg:
32232 0x11/imm32/alloc-id:fake:payload
32233 0x11/imm32/alloc-id:fake
32234 Float-var-in-mem/imm32
32235 0x11/imm32/alloc-id:fake
32236 Single-float-var-in-some-register/imm32/next
32237
32238 Single-int-var-in-some-register:
32239 0x11/imm32/alloc-id:fake:payload
32240 0x11/imm32/alloc-id:fake
32241 Int-var-in-some-register/imm32
32242 0/imm32/next
32243 0/imm32/next
32244
32245 Single-addr-var-in-some-register:
32246 0x11/imm32/alloc-id:fake:payload
32247 0x11/imm32/alloc-id:fake
32248 Addr-var-in-some-register/imm32
32249 0/imm32/next
32250 0/imm32/next
32251
32252 Single-byte-var-in-some-register:
32253 0x11/imm32/alloc-id:fake:payload
32254 0x11/imm32/alloc-id:fake
32255 Byte-var-in-some-register/imm32
32256 0/imm32/next
32257 0/imm32/next
32258
32259 Int-var-in-some-register:
32260 0x11/imm32/alloc-id:fake:payload
32261 0/imm32/name
32262 0/imm32/name
32263 0x11/imm32/alloc-id:fake
32264 Type-int/imm32
32265 1/imm32/some-block-depth
32266 0/imm32/no-stack-offset
32267 0x11/imm32/alloc-id:fake
32268 Any-register/imm32
32269
32270 Any-register:
32271 0x11/imm32/alloc-id:fake:payload
32272 1/imm32/size
32273
32274 2a/asterisk
32275
32276 Addr-var-in-some-register:
32277 0x11/imm32/alloc-id:fake:payload
32278 0/imm32/name
32279 0/imm32/name
32280 0x11/imm32/alloc-id:fake
32281 Type-addr/imm32
32282 1/imm32/some-block-depth
32283 0/imm32/no-stack-offset
32284 0x11/imm32/alloc-id:fake
32285 Any-register/imm32
32286
32287 Byte-var-in-some-register:
32288 0x11/imm32/alloc-id:fake:payload
32289 0/imm32/name
32290 0/imm32/name
32291 0x11/imm32/alloc-id:fake
32292 Type-byte/imm32
32293 1/imm32/some-block-depth
32294 0/imm32/no-stack-offset
32295 0x11/imm32/alloc-id:fake
32296 Any-register/imm32
32297
32298 Single-int-var-in-eax:
32299 0x11/imm32/alloc-id:fake:payload
32300 0x11/imm32/alloc-id:fake
32301 Int-var-in-eax/imm32
32302 0/imm32/next
32303 0/imm32/next
32304
32305 Int-var-in-eax:
32306 0x11/imm32/alloc-id:fake:payload
32307 0/imm32/name
32308 0/imm32/name
32309 0x11/imm32/alloc-id:fake
32310 Type-int/imm32
32311 1/imm32/some-block-depth
32312 0/imm32/no-stack-offset
32313 0x11/imm32/alloc-id:fake
32314 $Mu-register-eax/imm32
32315
32316 Single-int-var-in-ecx:
32317 0x11/imm32/alloc-id:fake:payload
32318 0x11/imm32/alloc-id:fake
32319 Int-var-in-ecx/imm32
32320 0/imm32/next
32321 0/imm32/next
32322
32323 Int-var-in-ecx:
32324 0x11/imm32/alloc-id:fake:payload
32325 0/imm32/name
32326 0/imm32/name
32327 0x11/imm32/alloc-id:fake
32328 Type-int/imm32
32329 1/imm32/some-block-depth
32330 0/imm32/no-stack-offset
32331 0x11/imm32/alloc-id:fake
32332 $Register-ecx/imm32/register
32333
32334 Single-int-var-in-edx:
32335 0x11/imm32/alloc-id:fake:payload
32336 0x11/imm32/alloc-id:fake
32337 Int-var-in-edx/imm32
32338 0/imm32/next
32339 0/imm32/next
32340
32341 Int-var-in-edx:
32342 0x11/imm32/alloc-id:fake:payload
32343 0/imm32/name
32344 0/imm32/name
32345 0x11/imm32/alloc-id:fake
32346 Type-int/imm32
32347 1/imm32/some-block-depth
32348 0/imm32/no-stack-offset
32349 0x11/imm32/alloc-id:fake
32350 $Register-edx/imm32/register
32351
32352 Single-int-var-in-ebx:
32353 0x11/imm32/alloc-id:fake:payload
32354 0x11/imm32/alloc-id:fake
32355 Int-var-in-ebx/imm32
32356 0/imm32/next
32357 0/imm32/next
32358
32359 Int-var-in-ebx:
32360 0x11/imm32/alloc-id:fake:payload
32361 0/imm32/name
32362 0/imm32/name
32363 0x11/imm32/alloc-id:fake
32364 Type-int/imm32
32365 1/imm32/some-block-depth
32366 0/imm32/no-stack-offset
32367 0x11/imm32/alloc-id:fake
32368 $Register-ebx/imm32/register
32369
32370 Single-int-var-in-esi:
32371 0x11/imm32/alloc-id:fake:payload
32372 0x11/imm32/alloc-id:fake
32373 Int-var-in-esi/imm32
32374 0/imm32/next
32375 0/imm32/next
32376
32377 Int-var-in-esi:
32378 0x11/imm32/alloc-id:fake:payload
32379 0/imm32/name
32380 0/imm32/name
32381 0x11/imm32/alloc-id:fake
32382 Type-int/imm32
32383 1/imm32/some-block-depth
32384 0/imm32/no-stack-offset
32385 0x11/imm32/alloc-id:fake
32386 $Register-esi/imm32/register
32387
32388 Single-int-var-in-edi:
32389 0x11/imm32/alloc-id:fake:payload
32390 0x11/imm32/alloc-id:fake
32391 Int-var-in-edi/imm32
32392 0/imm32/next
32393 0/imm32/next
32394
32395 Int-var-in-edi:
32396 0x11/imm32/alloc-id:fake:payload
32397 0/imm32/name
32398 0/imm32/name
32399 0x11/imm32/alloc-id:fake
32400 Type-int/imm32
32401 1/imm32/some-block-depth
32402 0/imm32/no-stack-offset
32403 0x11/imm32/alloc-id:fake
32404 $Register-edi/imm32/register
32405
32406 Single-lit-var:
32407 0x11/imm32/alloc-id:fake:payload
32408 0x11/imm32/alloc-id:fake
32409 Lit-var/imm32
32410 0/imm32/next
32411 0/imm32/next
32412
32413 Lit-var:
32414 0x11/imm32/alloc-id:fake:payload
32415 0/imm32/name
32416 0/imm32/name
32417 0x11/imm32/alloc-id:fake
32418 Type-literal/imm32
32419 1/imm32/some-block-depth
32420 0/imm32/no-stack-offset
32421 0/imm32/no-register
32422 0/imm32/no-register
32423
32424 Single-float-var-in-mem:
32425 0x11/imm32/alloc-id:fake:payload
32426 0x11/imm32/alloc-id:fake
32427 Float-var-in-mem/imm32
32428 0/imm32/next
32429 0/imm32/next
32430
32431 Float-var-in-mem:
32432 0x11/imm32/alloc-id:fake:payload
32433 0/imm32/name
32434 0/imm32/name
32435 0x11/imm32/alloc-id:fake
32436 Type-float/imm32
32437 1/imm32/some-block-depth
32438 1/imm32/some-stack-offset
32439 0/imm32/no-register
32440 0/imm32/no-register
32441
32442 Single-float-var-in-some-register:
32443 0x11/imm32/alloc-id:fake:payload
32444 0x11/imm32/alloc-id:fake
32445 Float-var-in-some-register/imm32
32446 0/imm32/next
32447 0/imm32/next
32448
32449 Float-var-in-some-register:
32450 0x11/imm32/alloc-id:fake:payload
32451 0/imm32/name
32452 0/imm32/name
32453 0x11/imm32/alloc-id:fake
32454 Type-float/imm32
32455 1/imm32/some-block-depth
32456 0/imm32/no-stack-offset
32457 0x11/imm32/alloc-id:fake
32458 Any-register/imm32
32459
32460 Type-int:
32461 0x11/imm32/alloc-id:fake:payload
32462 1/imm32/is-atom
32463 1/imm32/value:int
32464 0/imm32/left:unused
32465 0/imm32/right:null
32466 0/imm32/right:null
32467
32468 Type-literal:
32469 0x11/imm32/alloc-id:fake:payload
32470 1/imm32/is-atom
32471 0/imm32/value:literal
32472 0/imm32/left:unused
32473 0/imm32/right:null
32474 0/imm32/right:null
32475
32476 Type-addr:
32477 0x11/imm32/alloc-id:fake:payload
32478 1/imm32/is-atom
32479 2/imm32/value:addr
32480 0/imm32/left:unused
32481 0/imm32/right:null
32482 0/imm32/right:null
32483
32484 Type-byte:
32485 0x11/imm32/alloc-id:fake:payload
32486 1/imm32/is-atom
32487 8/imm32/value:byte
32488 0/imm32/left:unused
32489 0/imm32/right:null
32490 0/imm32/right:null
32491
32492 Type-float:
32493 0x11/imm32/alloc-id:fake:payload
32494 1/imm32/is-atom
32495 0xf/imm32/value:float
32496 0/imm32/left:unused
32497 0/imm32/right:null
32498 0/imm32/right:null
32499
32500 == code
32501 emit-subx-primitive:
32502
32503 55/push-ebp
32504 89/<- %ebp 4/r32/esp
32505
32506 50/push-eax
32507 51/push-ecx
32508
32509 8b/-> *(ebp+0x10) 1/r32/ecx
32510
32511 (emit-indent *(ebp+8) *Curr-block-depth)
32512 (lookup *(ecx+0x18) *(ecx+0x1c))
32513 (write-buffered *(ebp+8) %eax)
32514
32515 (emit-subx-rm32 *(ebp+8) *(ecx+0x20) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18))
32516
32517 (emit-subx-rm32 *(ebp+8) *(ecx+0x34) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18))
32518
32519 (emit-subx-r32 *(ebp+8) *(ecx+0x24) *(ebp+0xc))
32520
32521 (emit-subx-x32 *(ebp+8) *(ecx+0x38) *(ebp+0xc))
32522
32523 (emit-subx-imm32 *(ebp+8) *(ecx+0x28) *(ebp+0xc))
32524
32525 (emit-subx-imm8 *(ebp+8) *(ecx+0x2c) *(ebp+0xc))
32526
32527 (emit-subx-disp32 *(ebp+8) *(ecx+0x30) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18))
32528 (write-buffered *(ebp+8) Newline)
32529 $emit-subx-primitive:end:
32530
32531 59/pop-to-ecx
32532 58/pop-to-eax
32533
32534 89/<- %esp 5/r32/ebp
32535 5d/pop-to-ebp
32536 c3/return
32537
32538 emit-subx-rm32:
32539
32540 55/push-ebp
32541 89/<- %ebp 4/r32/esp
32542
32543 50/push-eax
32544
32545 81 7/subop/compare *(ebp+0xc) 0/imm32
32546 74/jump-if-= $emit-subx-rm32:end/disp8
32547
32548 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18))
32549 (emit-subx-var-as-rm32 *(ebp+8) %eax)
32550 $emit-subx-rm32:end:
32551
32552 58/pop-to-eax
32553
32554 89/<- %esp 5/r32/ebp
32555 5d/pop-to-ebp
32556 c3/return
32557
32558 get-stmt-operand-from-arg-location:
32559
32560 55/push-ebp
32561 89/<- %ebp 4/r32/esp
32562
32563 51/push-ecx
32564
32565 8b/-> *(ebp+0xc) 0/r32/eax
32566
32567 8b/-> *(ebp+8) 1/r32/ecx
32568
32569 {
32570 3d/compare-eax-and 1/imm32
32571 75/jump-if-!= break/disp8
32572 $get-stmt-operand-from-arg-location:1:
32573 (lookup *(ecx+0xc) *(ecx+0x10))
32574 eb/jump $get-stmt-operand-from-arg-location:end/disp8
32575 }
32576
32577 {
32578 3d/compare-eax-and 2/imm32
32579 75/jump-if-!= break/disp8
32580 $get-stmt-operand-from-arg-location:2:
32581 (lookup *(ecx+0xc) *(ecx+0x10))
32582 (lookup *(eax+8) *(eax+0xc))
32583 eb/jump $get-stmt-operand-from-arg-location:end/disp8
32584 }
32585
32586 {
32587 3d/compare-eax-and 3/imm32
32588 75/jump-if-!= break/disp8
32589 $get-stmt-operand-from-arg-location:3:
32590 (lookup *(ecx+0x14) *(ecx+0x18))
32591 eb/jump $get-stmt-operand-from-arg-location:end/disp8
32592 }
32593
32594 e9/jump $get-stmt-operand-from-arg-location:abort/disp32
32595 $get-stmt-operand-from-arg-location:end:
32596
32597 59/pop-to-ecx
32598
32599 89/<- %esp 5/r32/ebp
32600 5d/pop-to-ebp
32601 c3/return
32602
32603 $get-stmt-operand-from-arg-location:abort:
32604
32605 (write-buffered *(ebp+0x10) "invalid arg-location ")
32606 (write-int32-hex-buffered *(ebp+0x10) %eax)
32607 (write-buffered *(ebp+0x10) Newline)
32608 (flush *(ebp+0x10))
32609 (stop *(ebp+0x14) 1)
32610
32611
32612 emit-subx-r32:
32613
32614 55/push-ebp
32615 89/<- %ebp 4/r32/esp
32616
32617 50/push-eax
32618 51/push-ecx
32619
32620 81 7/subop/compare *(ebp+0xc) 0/imm32
32621 0f 84/jump-if-= $emit-subx-r32:end/disp32
32622
32623 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc))
32624 (lookup *eax *(eax+4))
32625 (lookup *(eax+0x18) *(eax+0x1c))
32626
32627
32628
32629
32630 (maybe-get Mu-registers %eax 0xc)
32631 (write-buffered *(ebp+8) Space)
32632 (write-int32-hex-buffered *(ebp+8) *eax)
32633 (write-buffered *(ebp+8) "/r32")
32634 $emit-subx-r32:end:
32635
32636 59/pop-to-ecx
32637 58/pop-to-eax
32638
32639 89/<- %esp 5/r32/ebp
32640 5d/pop-to-ebp
32641 c3/return
32642
32643 emit-subx-x32:
32644
32645 55/push-ebp
32646 89/<- %ebp 4/r32/esp
32647
32648 50/push-eax
32649 51/push-ecx
32650
32651 81 7/subop/compare *(ebp+0xc) 0/imm32
32652 0f 84/jump-if-= $emit-subx-x32:end/disp32
32653
32654 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc))
32655 (lookup *eax *(eax+4))
32656 (lookup *(eax+0x18) *(eax+0x1c))
32657
32658
32659
32660
32661 (maybe-get Mu-registers %eax 0xc)
32662 (write-buffered *(ebp+8) Space)
32663 (write-int32-hex-buffered *(ebp+8) *eax)
32664 (write-buffered *(ebp+8) "/x32")
32665 $emit-subx-x32:end:
32666
32667 59/pop-to-ecx
32668 58/pop-to-eax
32669
32670 89/<- %esp 5/r32/ebp
32671 5d/pop-to-ebp
32672 c3/return
32673
32674 emit-subx-imm32:
32675
32676 55/push-ebp
32677 89/<- %ebp 4/r32/esp
32678
32679 50/push-eax
32680 51/push-ecx
32681
32682 81 7/subop/compare *(ebp+0xc) 0/imm32
32683 0f 84/jump-if-= $emit-subx-imm32:end/disp32
32684
32685 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc))
32686 (lookup *eax *(eax+4))
32687 (lookup *eax *(eax+4))
32688 (write-buffered *(ebp+8) Space)
32689 (write-buffered *(ebp+8) %eax)
32690 (write-buffered *(ebp+8) "/imm32")
32691 $emit-subx-imm32:end:
32692
32693 59/pop-to-ecx
32694 58/pop-to-eax
32695
32696 89/<- %esp 5/r32/ebp
32697 5d/pop-to-ebp
32698 c3/return
32699
32700 emit-subx-imm8:
32701
32702 55/push-ebp
32703 89/<- %ebp 4/r32/esp
32704
32705 50/push-eax
32706 51/push-ecx
32707
32708 81 7/subop/compare *(ebp+0xc) 0/imm32
32709 0f 84/jump-if-= $emit-subx-imm32:end/disp32
32710
32711 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc))
32712 (lookup *eax *(eax+4))
32713 (lookup *eax *(eax+4))
32714 (write-buffered *(ebp+8) Space)
32715 (write-buffered *(ebp+8) %eax)
32716 (write-buffered *(ebp+8) "/imm8")
32717 $emit-subx-imm8:end:
32718
32719 59/pop-to-ecx
32720 58/pop-to-eax
32721
32722 89/<- %esp 5/r32/ebp
32723 5d/pop-to-ebp
32724 c3/return
32725
32726 emit-subx-disp32:
32727
32728 55/push-ebp
32729 89/<- %ebp 4/r32/esp
32730
32731 50/push-eax
32732 51/push-ecx
32733
32734 81 7/subop/compare *(ebp+0xc) 0/imm32
32735 0f 84/jump-if-= $emit-subx-disp32:end/disp32
32736
32737 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18))
32738 (lookup *eax *(eax+4))
32739 (lookup *eax *(eax+4))
32740 (write-buffered *(ebp+8) Space)
32741 (write-buffered *(ebp+8) %eax)
32742
32743
32744 8b/-> *(ebp+0x10) 0/r32/eax
32745 (lookup *(eax+4) *(eax+8))
32746 89/<- %ecx 0/r32/eax
32747 {
32748 (string-starts-with? %ecx "break")
32749 3d/compare-eax-and 0/imm32/false
32750 74/jump-if-= break/disp8
32751 (write-buffered *(ebp+8) ":break")
32752 }
32753
32754 {
32755 (string-starts-with? %ecx "loop")
32756 3d/compare-eax-and 0/imm32/false
32757 74/jump-if-= break/disp8
32758 (write-buffered *(ebp+8) ":loop")
32759 }
32760 (write-buffered *(ebp+8) "/disp32")
32761 $emit-subx-disp32:end:
32762
32763 59/pop-to-ecx
32764 58/pop-to-eax
32765
32766 89/<- %esp 5/r32/ebp
32767 5d/pop-to-ebp
32768 c3/return
32769
32770 emit-call:
32771
32772 55/push-ebp
32773 89/<- %ebp 4/r32/esp
32774
32775 50/push-eax
32776 51/push-ecx
32777
32778 (emit-indent *(ebp+8) *Curr-block-depth)
32779 (write-buffered *(ebp+8) "(")
32780
32781 8b/-> *(ebp+0xc) 1/r32/ecx
32782
32783 (lookup *(ecx+4) *(ecx+8))
32784 (write-buffered *(ebp+8) %eax)
32785
32786
32787 (lookup *(ecx+0xc) *(ecx+0x10))
32788 {
32789
32790 3d/compare-eax-and 0/imm32
32791 74/jump-if-= break/disp8
32792
32793 (emit-subx-call-operand *(ebp+8) %eax)
32794
32795 (lookup *(eax+8) *(eax+0xc))
32796 eb/jump loop/disp8
32797 }
32798
32799 (write-buffered *(ebp+8) ")\n")
32800 $emit-call:end:
32801
32802 59/pop-to-ecx
32803 58/pop-to-eax
32804
32805 89/<- %esp 5/r32/ebp
32806 5d/pop-to-ebp
32807 c3/return
32808
32809 emit-subx-call-operand:
32810
32811
32812 55/push-ebp
32813 89/<- %ebp 4/r32/esp
32814
32815 50/push-eax
32816 51/push-ecx
32817 56/push-esi
32818
32819 8b/-> *(ebp+0xc) 1/r32/ecx
32820
32821 (lookup *ecx *(ecx+4))
32822 89/<- %esi 0/r32/eax
32823
32824 {
32825 $emit-subx-call-operand:check-for-register-direct:
32826 81 7/subop/compare *(esi+0x18) 0/imm32
32827 74/jump-if-= break/disp8
32828 81 7/subop/compare *(ecx+0x10) 0/imm32/false
32829 75/jump-if-!= break/disp8
32830 $emit-subx-call-operand:register-direct:
32831 (write-buffered *(ebp+8) " %")
32832 (lookup *(esi+0x18) *(esi+0x1c))
32833 (write-buffered *(ebp+8) %eax)
32834 e9/jump $emit-subx-call-operand:end/disp32
32835 }
32836
32837 {
32838 $emit-subx-call-operand:check-for-register-indirect:
32839 81 7/subop/compare *(esi+0x18) 0/imm32
32840 74/jump-if-= break/disp8
32841 81 7/subop/compare *(ecx+0x10) 0/imm32/false
32842 74/jump-if-= break/disp8
32843 $emit-subx-call-operand:register-indirect:
32844 (emit-subx-call-operand-register-indirect *(ebp+8) %esi)
32845 e9/jump $emit-subx-call-operand:end/disp32
32846 }
32847
32848 {
32849 81 7/subop/compare *(esi+0x14) 0/imm32
32850 74/jump-if-= break/disp8
32851 $emit-subx-call-operand:stack:
32852 (emit-subx-call-operand-stack *(ebp+8) %esi)
32853 e9/jump $emit-subx-call-operand:end/disp32
32854 }
32855
32856 {
32857 (lookup *(esi+8) *(esi+0xc))
32858 81 7/subop/compare *(eax+4) 0/imm32
32859 75/jump-if-!= break/disp8
32860 $emit-subx-call-operand:literal:
32861 (write-buffered *(ebp+8) Space)
32862 (lookup *esi *(esi+4))
32863 (write-buffered *(ebp+8) %eax)
32864 e9/jump $emit-subx-call-operand:end/disp32
32865 }
32866
32867 {
32868 (lookup *(esi+8) *(esi+0xc))
32869 81 7/subop/compare *(eax+4) 0x10/imm32
32870 75/jump-if-!= break/disp8
32871 $emit-subx-call-operand:literal-string:
32872 (write-buffered *(ebp+8) Space)
32873 (lookup *esi *(esi+4))
32874 (write-buffered *(ebp+8) %eax)
32875 }
32876 $emit-subx-call-operand:end:
32877
32878 5e/pop-to-esi
32879 59/pop-to-ecx
32880 58/pop-to-eax
32881
32882 89/<- %esp 5/r32/ebp
32883 5d/pop-to-ebp
32884 c3/return
32885
32886 emit-subx-call-operand-register-indirect:
32887
32888 55/push-ebp
32889 89/<- %ebp 4/r32/esp
32890
32891 50/push-eax
32892 51/push-ecx
32893 56/push-esi
32894
32895 8b/-> *(ebp+0xc) 6/r32/esi
32896
32897 (size-of-deref %esi)
32898 89/<- %ecx 0/r32/eax
32899
32900 (lookup *(esi+0x18) *(esi+0x1c))
32901 89/<- %esi 0/r32/eax
32902
32903
32904 b8/copy-to-eax 0/imm32
32905 {
32906 $emit-subx-call-operand-register-indirect:loop:
32907
32908 39/compare %eax 1/r32/ecx
32909 7d/jump-if->= break/disp8
32910
32911 (write-buffered *(ebp+8) " *(")
32912 (write-buffered *(ebp+8) %esi)
32913 (write-buffered *(ebp+8) "+")
32914 (write-int32-hex-buffered *(ebp+8) %eax)
32915 (write-buffered *(ebp+8) ")")
32916
32917 05/add-to-eax 4/imm32
32918
32919 eb/jump loop/disp8
32920 }
32921 $emit-subx-call-operand-register-indirect:end:
32922
32923 5e/pop-to-esi
32924 59/pop-to-ecx
32925 58/pop-to-eax
32926
32927 89/<- %esp 5/r32/ebp
32928 5d/pop-to-ebp
32929 c3/return
32930
32931 emit-subx-call-operand-stack:
32932
32933 55/push-ebp
32934 89/<- %ebp 4/r32/esp
32935
32936 50/push-eax
32937 51/push-ecx
32938 56/push-esi
32939
32940 8b/-> *(ebp+0xc) 6/r32/esi
32941
32942 8b/-> *(esi+0x14) 1/r32/ecx
32943
32944 (size-of %esi)
32945
32946 01/add-to %eax 1/r32/ecx
32947 {
32948 $emit-subx-call-operand-stack:loop:
32949
32950 39/compare %ecx 0/r32/eax
32951 7d/jump-if->= break/disp8
32952
32953 (write-buffered *(ebp+8) " *(ebp+")
32954 (write-int32-hex-buffered *(ebp+8) %ecx)
32955 (write-buffered *(ebp+8) ")")
32956
32957 81 0/subop/add %ecx 4/imm32
32958
32959 eb/jump loop/disp8
32960 }
32961 $emit-subx-call-operand-stack:end:
32962
32963 5e/pop-to-esi
32964 59/pop-to-ecx
32965 58/pop-to-eax
32966
32967 89/<- %esp 5/r32/ebp
32968 5d/pop-to-ebp
32969 c3/return
32970
32971 emit-subx-var-as-rm32:
32972
32973 55/push-ebp
32974 89/<- %ebp 4/r32/esp
32975
32976 50/push-eax
32977 51/push-ecx
32978 56/push-esi
32979
32980 8b/-> *(ebp+0xc) 1/r32/ecx
32981
32982 (lookup *ecx *(ecx+4))
32983 89/<- %esi 0/r32/eax
32984
32985 {
32986 $emit-subx-var-as-rm32:check-for-register-indirect:
32987 81 7/subop/compare *(esi+0x18) 0/imm32
32988 74/jump-if-= break/disp8
32989 81 7/subop/compare *(ecx+0x10) 0/imm32/false
32990 74/jump-if-= break/disp8
32991 $emit-subx-var-as-rm32:register-indirect:
32992 (write-buffered *(ebp+8) " *")
32993 (lookup *(esi+0x18) *(esi+0x1c))
32994 (write-buffered *(ebp+8) %eax)
32995 e9/jump $emit-subx-var-as-rm32:end/disp32
32996 }
32997
32998 {
32999 $emit-subx-var-as-rm32:check-for-register-direct:
33000 81 7/subop/compare *(esi+0x18) 0/imm32
33001 74/jump-if-= break/disp8
33002 81 7/subop/compare *(ecx+0x10) 0/imm32/false
33003 75/jump-if-!= break/disp8
33004 $emit-subx-var-as-rm32:register-direct:
33005 (write-buffered *(ebp+8) " %")
33006 (lookup *(esi+0x18) *(esi+0x1c))
33007 (write-buffered *(ebp+8) %eax)
33008 e9/jump $emit-subx-var-as-rm32:end/disp32
33009 }
33010
33011 {
33012 81 7/subop/compare *(esi+0x14) 0/imm32
33013 74/jump-if-= break/disp8
33014 $emit-subx-var-as-rm32:stack:
33015 (write-buffered *(ebp+8) Space)
33016 (write-buffered *(ebp+8) "*(ebp+")
33017 (write-int32-hex-buffered *(ebp+8) *(esi+0x14))
33018 (write-buffered *(ebp+8) ")")
33019 }
33020 $emit-subx-var-as-rm32:end:
33021
33022 5e/pop-to-esi
33023 59/pop-to-ecx
33024 58/pop-to-eax
33025
33026 89/<- %esp 5/r32/ebp
33027 5d/pop-to-ebp
33028 c3/return
33029
33030 find-matching-primitive:
33031
33032 55/push-ebp
33033 89/<- %ebp 4/r32/esp
33034
33035 51/push-ecx
33036
33037 8b/-> *(ebp+8) 1/r32/ecx
33038 {
33039 $find-matching-primitive:loop:
33040
33041 81 7/subop/compare %ecx 0/imm32
33042 74/jump-if-= break/disp8
33043
33044 {
33045 (mu-stmt-matches-primitive? *(ebp+0xc) %ecx)
33046 3d/compare-eax-and 0/imm32/false
33047 74/jump-if-= break/disp8
33048 89/<- %eax 1/r32/ecx
33049 eb/jump $find-matching-primitive:end/disp8
33050 }
33051 $find-matching-primitive:next-primitive:
33052
33053 (lookup *(ecx+0x3c) *(ecx+0x40))
33054 89/<- %ecx 0/r32/eax
33055
33056 e9/jump loop/disp32
33057 }
33058
33059 b8/copy-to-eax 0/imm32
33060 $find-matching-primitive:end:
33061
33062 59/pop-to-ecx
33063
33064 89/<- %esp 5/r32/ebp
33065 5d/pop-to-ebp
33066 c3/return
33067
33068 mu-stmt-matches-primitive?:
33069
33070
33071
33072
33073
33074
33075 55/push-ebp
33076 89/<- %ebp 4/r32/esp
33077
33078 51/push-ecx
33079 52/push-edx
33080 53/push-ebx
33081 56/push-esi
33082 57/push-edi
33083
33084 8b/-> *(ebp+8) 1/r32/ecx
33085
33086 8b/-> *(ebp+0xc) 2/r32/edx
33087 {
33088 $mu-stmt-matches-primitive?:check-name:
33089
33090
33091 (lookup *(ecx+4) *(ecx+8))
33092 89/<- %esi 0/r32/eax
33093
33094 (lookup *edx *(edx+4))
33095
33096
33097
33098 89/<- %edi 0/r32/eax
33099 (string-equal? %esi %edi)
33100 3d/compare-eax-and 0/imm32/false
33101 75/jump-if-!= break/disp8
33102 b8/copy-to-eax 0/imm32
33103 e9/jump $mu-stmt-matches-primitive?:end/disp32
33104 }
33105
33106 (lookup *(ecx+0xc) *(ecx+0x10))
33107 89/<- %esi 0/r32/eax
33108
33109 (lookup *(edx+8) *(edx+0xc))
33110 89/<- %edi 0/r32/eax
33111 {
33112 $mu-stmt-matches-primitive?:inouts-loop:
33113
33114 {
33115 $mu-stmt-matches-primitive?:check-both-inouts-null:
33116 81 7/subop/compare %esi 0/imm32
33117 75/jump-if-!= break/disp8
33118 $mu-stmt-matches-primitive?:stmt-inout-null:
33119 81 7/subop/compare %edi 0/imm32
33120 0f 84/jump-if-= $mu-stmt-matches-primitive?:check-outputs/disp32
33121 $mu-stmt-matches-primitive?:stmt-inout-null-and-prim-inout-not-null:
33122
33123 b8/copy-to-eax 0/imm32/false
33124 e9/jump $mu-stmt-matches-primitive?:end/disp32
33125 }
33126
33127 {
33128 $mu-stmt-matches-primitive?:check-prim-inout-null:
33129 81 7/subop/compare %edi 0/imm32
33130 75/jump-if-!= break/disp8
33131 $mu-stmt-matches-primitive?:prim-inout-null:
33132 b8/copy-to-eax 0/imm32/false
33133 e9/jump $mu-stmt-matches-primitive?:end/disp32
33134 }
33135
33136 {
33137 $mu-stmt-matches-primitive?:check-inouts-match:
33138 (lookup *edi *(edi+4))
33139 (operand-matches-primitive? %esi %eax)
33140 3d/compare-eax-and 0/imm32/false
33141 75/jump-if-!= break/disp8
33142 $mu-stmt-matches-primitive?:inouts-match:
33143 b8/copy-to-eax 0/imm32/false
33144 e9/jump $mu-stmt-matches-primitive?:end/disp32
33145 }
33146 $mu-stmt-matches-primitive?:next-inout:
33147
33148 (lookup *(esi+8) *(esi+0xc))
33149 89/<- %esi 0/r32/eax
33150
33151 (lookup *(edi+8) *(edi+0xc))
33152 89/<- %edi 0/r32/eax
33153
33154 e9/jump loop/disp32
33155 }
33156 $mu-stmt-matches-primitive?:check-outputs:
33157
33158 (lookup *(ecx+0x14) *(ecx+0x18))
33159 89/<- %esi 0/r32/eax
33160
33161 (lookup *(edx+0x10) *(edx+0x14))
33162 89/<- %edi 0/r32/eax
33163 {
33164 $mu-stmt-matches-primitive?:outputs-loop:
33165
33166 {
33167 $mu-stmt-matches-primitive?:check-both-outputs-null:
33168 81 7/subop/compare %esi 0/imm32
33169 75/jump-if-!= break/disp8
33170 {
33171 $mu-stmt-matches-primitive?:stmt-output-null:
33172 81 7/subop/compare %edi 0/imm32
33173 75/jump-if-!= break/disp8
33174 $mu-stmt-matches-primitive?:both-outputs-null:
33175
33176 b8/copy-to-eax 1/imm32
33177 e9/jump $mu-stmt-matches-primitive?:end/disp32
33178 }
33179 $mu-stmt-matches-primitive?:stmt-output-null-and-prim-output-not-null:
33180
33181 b8/copy-to-eax 0/imm32
33182 e9/jump $mu-stmt-matches-primitive?:end/disp32
33183 }
33184
33185 {
33186 $mu-stmt-matches-primitive?:check-prim-output-null:
33187 81 7/subop/compare %edi 0/imm32
33188 75/jump-if-!= break/disp8
33189 $mu-stmt-matches-primitive?:prim-output-is-null:
33190 b8/copy-to-eax 0/imm32
33191 e9/jump $mu-stmt-matches-primitive?:end/disp32
33192 }
33193
33194 {
33195 $mu-stmt-matches-primitive?:check-outputs-match:
33196 (lookup *edi *(edi+4))
33197 (operand-matches-primitive? %esi %eax)
33198 3d/compare-eax-and 0/imm32/false
33199 75/jump-if-!= break/disp8
33200 $mu-stmt-matches-primitive?:outputs-match:
33201 b8/copy-to-eax 0/imm32
33202 e9/jump $mu-stmt-matches-primitive?:end/disp32
33203 }
33204 $mu-stmt-matches-primitive?:next-output:
33205
33206 (lookup *(esi+8) *(esi+0xc))
33207 89/<- %esi 0/r32/eax
33208
33209 (lookup *(edi+8) *(edi+0xc))
33210 89/<- %edi 0/r32/eax
33211
33212 e9/jump loop/disp32
33213 }
33214 $mu-stmt-matches-primitive?:return-true:
33215 b8/copy-to-eax 1/imm32
33216 $mu-stmt-matches-primitive?:end:
33217
33218 5f/pop-to-edi
33219 5e/pop-to-esi
33220 5b/pop-to-ebx
33221 5a/pop-to-edx
33222 59/pop-to-ecx
33223
33224 89/<- %esp 5/r32/ebp
33225 5d/pop-to-ebp
33226 c3/return
33227
33228 operand-matches-primitive?:
33229
33230 55/push-ebp
33231 89/<- %ebp 4/r32/esp
33232
33233 51/push-ecx
33234 52/push-edx
33235 53/push-ebx
33236 56/push-esi
33237 57/push-edi
33238
33239 8b/-> *(ebp+8) 1/r32/ecx
33240
33241 (lookup *ecx *(ecx+4))
33242 89/<- %esi 0/r32/eax
33243
33244 8b/-> *(ebp+0xc) 7/r32/edi
33245 $operand-matches-primitive?:check-type:
33246
33247
33248 (lookup *(esi+8) *(esi+0xc))
33249 89/<- %ebx 0/r32/eax
33250
33251 {
33252 81 7/subop/compare *(ecx+0x10) 0/imm32/false
33253 74/jump-if-= break/disp8
33254 $operand-matches-primitive?:is-deref:
33255
33256 (lookup *(ebx+0xc) *(ebx+0x10))
33257
33258 81 7/subop/compare *eax 0/imm32/false
33259 {
33260 75/jump-if-!= break/disp8
33261 (lookup *(eax+4) *(eax+8))
33262 }
33263
33264 89/<- %ebx 0/r32/eax
33265 }
33266
33267 (lookup *(edi+8) *(edi+0xc))
33268 (subx-type-category-match? %ebx %eax)
33269 3d/compare-eax-and 0/imm32/false
33270 0f 84/jump-if-= $operand-matches-primitive?:return-false/disp32
33271 {
33272 $operand-matches-primitive?:check-register:
33273
33274 {
33275 81 7/subop/compare *(edi+0x18) 0/imm32
33276 0f 85/jump-if-!= break/disp32
33277 81 7/subop/compare *(esi+0x18) 0/imm32
33278 74/jump-if-= break/disp8
33279 81 7/subop/compare *(ecx+0x10) 0/imm32/false
33280 74/jump-if-= break/disp8
33281 $operand-matches-primitive?:var-deref-match:
33282 e9/jump $operand-matches-primitive?:return-true/disp32
33283 }
33284
33285 {
33286 81 7/subop/compare *(edi+0x18) 0/imm32
33287 0f 84/jump-if-= break/disp32
33288 81 7/subop/compare *(esi+0x18) 0/imm32
33289 0f 84/jump-if-= break/disp32
33290 81 7/subop/compare *(ecx+0x10) 0/imm32/false
33291 74/jump-if-= break/disp8
33292 $operand-matches-primitive?:var-deref-no-match:
33293 e9/jump $operand-matches-primitive?:return-false/disp32
33294 }
33295
33296 {
33297
33298
33299 (lookup *(esi+0x18) *(esi+0x1c))
33300 89/<- %ebx 0/r32/eax
33301
33302 (lookup *(edi+0x18) *(edi+0x1c))
33303 89/<- %ecx 0/r32/eax
33304
33305 39/compare %ecx 3/r32/ebx
33306 74/jump-if-= break/disp8
33307 $operand-matches-primitive?:var-register-no-match:
33308
33309 81 7/subop/compare %ebx 0/imm32
33310 74/jump-if-= $operand-matches-primitive?:return-false/disp8
33311 81 7/subop/compare %ecx 0/imm32
33312 74/jump-if-= $operand-matches-primitive?:return-false/disp8
33313
33314 (string-equal? %ecx "*")
33315 3d/compare-eax-and 0/imm32/false
33316 75/jump-if-!= break/disp8
33317 $operand-matches-primitive?:wildcard-no-match:
33318
33319 (string-equal? %ecx %ebx)
33320 3d/compare-eax-and 0/imm32/false
33321 74/jump-if-= $operand-matches-primitive?:return-false/disp8
33322 }
33323 }
33324 $operand-matches-primitive?:return-true:
33325 b8/copy-to-eax 1/imm32/true
33326 eb/jump $operand-matches-primitive?:end/disp8
33327 $operand-matches-primitive?:return-false:
33328 b8/copy-to-eax 0/imm32/false
33329 $operand-matches-primitive?:end:
33330
33331 5f/pop-to-edi
33332 5e/pop-to-esi
33333 5b/pop-to-ebx
33334 5a/pop-to-edx
33335 59/pop-to-ecx
33336
33337 89/<- %esp 5/r32/ebp
33338 5d/pop-to-ebp
33339 c3/return
33340
33341 find-matching-function:
33342
33343 55/push-ebp
33344 89/<- %ebp 4/r32/esp
33345
33346 51/push-ecx
33347
33348 8b/-> *(ebp+8) 1/r32/ecx
33349 {
33350
33351 81 7/subop/compare %ecx 0/imm32
33352 74/jump-if-= break/disp8
33353
33354
33355
33356 {
33357 (mu-stmt-matches-function? *(ebp+0xc) %ecx)
33358 3d/compare-eax-and 0/imm32/false
33359 74/jump-if-= break/disp8
33360 89/<- %eax 1/r32/ecx
33361 eb/jump $find-matching-function:end/disp8
33362 }
33363
33364 (lookup *(ecx+0x20) *(ecx+0x24))
33365 89/<- %ecx 0/r32/eax
33366
33367 eb/jump loop/disp8
33368 }
33369
33370 b8/copy-to-eax 0/imm32
33371 $find-matching-function:end:
33372
33373 59/pop-to-ecx
33374
33375 89/<- %esp 5/r32/ebp
33376 5d/pop-to-ebp
33377 c3/return
33378
33379
33380 mu-stmt-matches-function?:
33381
33382 55/push-ebp
33383 89/<- %ebp 4/r32/esp
33384
33385 51/push-ecx
33386
33387
33388 8b/-> *(ebp+8) 0/r32/eax
33389 (lookup *(eax+4) *(eax+8))
33390 89/<- %ecx 0/r32/eax
33391
33392 8b/-> *(ebp+0xc) 0/r32/eax
33393 (lookup *eax *(eax+4))
33394 (string-equal? %eax %ecx)
33395 $mu-stmt-matches-function?:end:
33396
33397 59/pop-to-ecx
33398
33399 89/<- %esp 5/r32/ebp
33400 5d/pop-to-ebp
33401 c3/return
33402
33403
33404
33405 subx-type-category-match?:
33406
33407 55/push-ebp
33408 89/<- %ebp 4/r32/esp
33409
33410 51/push-ecx
33411
33412 (type-category *(ebp+8))
33413 89/<- %ecx 0/r32/eax
33414
33415 (type-category *(ebp+0xc))
33416
33417 39/compare %eax 1/r32/ecx
33418 0f 94/set-byte-if-= %al
33419 81 4/subop/and %eax 0xff/imm32
33420 $subx-type-category-match?:end:
33421
33422 59/pop-to-ecx
33423
33424 89/<- %esp 5/r32/ebp
33425 5d/pop-to-ebp
33426 c3/return
33427
33428 type-category:
33429
33430 55/push-ebp
33431 89/<- %ebp 4/r32/esp
33432
33433 51/push-ecx
33434
33435 (is-simple-mu-type? *(ebp+8) 0)
33436 89/<- %ecx 0/r32/eax
33437
33438 (is-simple-mu-type? *(ebp+8) 0xf)
33439
33440 c1/shift 4/subop/left %ecx 1/imm8
33441 09/or %eax 1/r32/ecx
33442 $type-category:end:
33443
33444 59/pop-to-ecx
33445
33446 89/<- %esp 5/r32/ebp
33447 5d/pop-to-ebp
33448 c3/return
33449
33450 is-simple-mu-type?:
33451
33452 55/push-ebp
33453 89/<- %ebp 4/r32/esp
33454
33455 51/push-ecx
33456
33457 8b/-> *(ebp+0xc) 1/r32/ecx
33458
33459 8b/-> *(ebp+8) 0/r32/eax
33460 39/compare *(eax+4) 1/r32/ecx
33461 0f 94/set-byte-if-= %al
33462 81 4/subop/and %eax 0xff/imm32
33463 $is-simple-mu-type?:end:
33464
33465 59/pop-to-ecx
33466
33467 89/<- %esp 5/r32/ebp
33468 5d/pop-to-ebp
33469 c3/return
33470
33471 is-mu-addr-type?:
33472
33473 55/push-ebp
33474 89/<- %ebp 4/r32/esp
33475
33476 8b/-> *(ebp+8) 0/r32/eax
33477
33478 81 7/subop/compare *eax 0/imm32/false
33479 {
33480 75/jump-if-!= break/disp8
33481 (lookup *(eax+4) *(eax+8))
33482 }
33483
33484 81 7/subop/compare *(eax+4) 2/imm32/addr
33485 0f 94/set-byte-if-= %al
33486 81 4/subop/and %eax 0xff/imm32
33487 $is-mu-addr-type?:end:
33488
33489 89/<- %esp 5/r32/ebp
33490 5d/pop-to-ebp
33491 c3/return
33492
33493 is-mu-array-type?:
33494
33495 55/push-ebp
33496 89/<- %ebp 4/r32/esp
33497
33498 8b/-> *(ebp+8) 0/r32/eax
33499
33500 81 7/subop/compare *eax 0/imm32/false
33501 {
33502 75/jump-if-!= break/disp8
33503 (lookup *(eax+4) *(eax+8))
33504 }
33505
33506 81 7/subop/compare *(eax+4) 3/imm32/array
33507 0f 94/set-byte-if-= %al
33508 81 4/subop/and %eax 0xff/imm32
33509 $is-mu-array-type?:end:
33510
33511 89/<- %esp 5/r32/ebp
33512 5d/pop-to-ebp
33513 c3/return
33514
33515 is-mu-string-type?:
33516
33517 55/push-ebp
33518 89/<- %ebp 4/r32/esp
33519
33520 56/push-esi
33521
33522 8b/-> *(ebp+8) 6/r32/esi
33523
33524 81 7/subop/compare *esi 0/imm32/false
33525 0f 85/jump-if-!= $is-mu-string-type?:return-false/disp32
33526
33527 (is-mu-addr-type? %esi)
33528 3d/compare-eax-with 0/imm32/false
33529 0f 84/jump-if-= $is-mu-string-type?:end/disp32
33530
33531 (lookup *(esi+0xc) *(esi+0x10))
33532 (is-mu-array-type? %eax)
33533 3d/compare-eax-with 0/imm32/false
33534 74/jump-if-= $is-mu-string-type?:end/disp8
33535
33536 (lookup *(esi+0xc) *(esi+0x10))
33537 (lookup *(eax+0xc) *(eax+0x10))
33538
33539 81 7/subop/compare *eax 0/imm32/false
33540 75/jump-if-!= $is-mu-string-type?:return-false/disp8
33541
33542 (lookup *(eax+4) *(eax+8))
33543 (is-simple-mu-type? %eax 8)
33544 eb/jump $is-mu-string-type?:end/disp8
33545 $is-mu-string-type?:return-false:
33546 b8/copy-to-eax 0/imm32/false
33547 $is-mu-string-type?:end:
33548
33549 5e/pop-to-esi
33550
33551 89/<- %esp 5/r32/ebp
33552 5d/pop-to-ebp
33553 c3/return
33554
33555 is-mu-stream-type?:
33556
33557 55/push-ebp
33558 89/<- %ebp 4/r32/esp
33559
33560 8b/-> *(ebp+8) 0/r32/eax
33561
33562 81 7/subop/compare *eax 0/imm32/false
33563 {
33564 75/jump-if-!= break/disp8
33565 (lookup *(eax+4) *(eax+8))
33566 }
33567
33568 81 7/subop/compare *(eax+4) 0xb/imm32/stream
33569 0f 94/set-byte-if-= %al
33570 81 4/subop/and %eax 0xff/imm32
33571 $is-mu-stream-type?:end:
33572
33573 89/<- %esp 5/r32/ebp
33574 5d/pop-to-ebp
33575 c3/return
33576
33577 test-emit-subx-stmt-primitive:
33578
33579
33580
33581
33582
33583
33584
33585
33586
33587
33588
33589
33590
33591
33592
33593
33594 55/push-ebp
33595 89/<- %ebp 4/r32/esp
33596
33597 (clear-stream _test-output-stream)
33598 (clear-stream $_test-output-buffered-file->buffer)
33599
33600 $test-emit-subx-stmt-primitive:initialize-type:
33601
33602 68/push 0/imm32/right:null
33603 68/push 0/imm32/right:null
33604 68/push 0/imm32/left:unused
33605 68/push 1/imm32/value:int
33606 68/push 1/imm32/is-atom?:true
33607 68/push 0x11/imm32/alloc-id:fake:payload
33608 89/<- %ecx 4/r32/esp
33609 $test-emit-subx-stmt-primitive:initialize-var:
33610
33611 68/push 0/imm32/no-register
33612 68/push 0/imm32/no-register
33613 68/push -8/imm32/stack-offset
33614 68/push 1/imm32/block-depth
33615 51/push-ecx/type
33616 68/push 0x11/imm32/alloc-id:fake
33617 68/push 0/imm32/name
33618 68/push 0/imm32/name
33619 68/push 0x11/imm32/alloc-id:fake:payload
33620 89/<- %ecx 4/r32/esp
33621 $test-emit-subx-stmt-primitive:initialize-var-name:
33622
33623 8d/copy-address *(ecx+4) 0/r32/eax
33624 (copy-array Heap "foo" %eax)
33625 $test-emit-subx-stmt-primitive:initialize-stmt-var:
33626
33627 68/push 0/imm32/is-deref:false
33628 68/push 0/imm32/next
33629 68/push 0/imm32/next
33630 51/push-ecx/var-foo
33631 68/push 0x11/imm32/alloc-id:fake
33632 68/push 0x11/imm32/alloc-id:fake:payload
33633 89/<- %ebx 4/r32/esp
33634 $test-emit-subx-stmt-primitive:initialize-stmt:
33635
33636 68/push 0/imm32/no-outputs
33637 68/push 0/imm32/no-outputs
33638 53/push-ebx/inouts
33639 68/push 0x11/imm32/alloc-id:fake
33640 68/push 0/imm32/operation
33641 68/push 0/imm32/operation
33642 68/push 1/imm32/tag
33643 89/<- %esi 4/r32/esp
33644 $test-emit-subx-stmt-primitive:initialize-stmt-operation:
33645
33646 8d/copy-address *(esi+4) 0/r32/eax
33647 (copy-array Heap "increment" %eax)
33648 $test-emit-subx-stmt-primitive:initialize-primitive:
33649
33650 68/push 0/imm32/next
33651 68/push 0/imm32/next
33652 68/push 0/imm32/no-x32
33653 68/push 0/imm32/no-xm32
33654 68/push 0/imm32/no-disp32
33655 68/push 0/imm32/no-imm8
33656 68/push 0/imm32/no-imm32
33657 68/push 0/imm32/no-r32
33658 68/push 1/imm32/rm32-is-first-inout
33659 68/push 0/imm32/subx-name
33660 68/push 0/imm32/subx-name
33661 68/push 0/imm32/no-outputs
33662 68/push 0/imm32/no-outputs
33663 53/push-ebx/inouts
33664 68/push 0x11/imm32/alloc-id:fake
33665 68/push 0/imm32/name
33666 68/push 0/imm32/name
33667 89/<- %ebx 4/r32/esp
33668 $test-emit-subx-stmt-primitive:initialize-primitive-name:
33669
33670 (copy-array Heap "increment" %ebx)
33671 $test-emit-subx-stmt-primitive:initialize-primitive-subx-name:
33672
33673 8d/copy-address *(ebx+0x18) 0/r32/eax
33674 (copy-array Heap "ff 0/subop/increment" %eax)
33675
33676 c7 0/subop/copy *Curr-block-depth 0/imm32
33677 (emit-subx-stmt _test-output-buffered-file %esi %ebx 0 Stderr 0)
33678 (flush _test-output-buffered-file)
33679 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
33685
33686 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment *(ebp+0xfffffff8)" "F - test-emit-subx-stmt-primitive")
33687
33688 89/<- %esp 5/r32/ebp
33689 5d/pop-to-ebp
33690 c3/return
33691
33692 test-emit-subx-stmt-primitive-register:
33693
33694
33695
33696
33697
33698
33699
33700
33701
33702
33703
33704
33705
33706
33707
33708
33709 55/push-ebp
33710 89/<- %ebp 4/r32/esp
33711
33712 (clear-stream _test-output-stream)
33713 (clear-stream $_test-output-buffered-file->buffer)
33714 $test-emit-subx-stmt-primitive-register:initialize-type:
33715
33716 68/push 0/imm32/right:null
33717 68/push 0/imm32/right:null
33718 68/push 0/imm32/left:unused
33719 68/push 1/imm32/value:int
33720 68/push 1/imm32/is-atom?:true
33721 68/push 0x11/imm32/alloc-id:fake:payload
33722 89/<- %ecx 4/r32/esp
33723 $test-emit-subx-stmt-primitive-register:initialize-var:
33724
33725 68/push 0/imm32/register
33726 68/push 0/imm32/register
33727 68/push 0/imm32/no-stack-offset
33728 68/push 1/imm32/block-depth
33729 51/push-ecx
33730 68/push 0x11/imm32/alloc-id:fake
33731 68/push 0/imm32/name
33732 68/push 0/imm32/name
33733 68/push 0x11/imm32/alloc-id:fake:payload
33734 89/<- %ecx 4/r32/esp
33735 $test-emit-subx-stmt-primitive-register:initialize-var-name:
33736
33737 8d/copy-address *(ecx+4) 0/r32/eax
33738 (copy-array Heap "foo" %eax)
33739 $test-emit-subx-stmt-primitive-register:initialize-var-register:
33740
33741 8d/copy-address *(ecx+0x1c) 0/r32/eax
33742 (copy-array Heap "eax" %eax)
33743 $test-emit-subx-stmt-primitive-register:initialize-stmt-var:
33744
33745 68/push 0/imm32/is-deref:false
33746 68/push 0/imm32/next
33747 68/push 0/imm32/next
33748 51/push-ecx/var-foo
33749 68/push 0x11/imm32/alloc-id:fake
33750 68/push 0x11/imm32/alloc-id:fake:payload
33751 89/<- %ebx 4/r32/esp
33752 $test-emit-subx-stmt-primitive-register:initialize-stmt:
33753
33754 53/push-ebx/outputs
33755 68/push 0x11/imm32/alloc-id:fake
33756 68/push 0/imm32/no-inouts
33757 68/push 0/imm32/no-inouts
33758 68/push 0/imm32/operation
33759 68/push 0/imm32/operation
33760 68/push 1/imm32
33761 89/<- %esi 4/r32/esp
33762 $test-emit-subx-stmt-primitive-register:initialize-stmt-operation:
33763
33764 8d/copy-address *(esi+4) 0/r32/eax
33765 (copy-array Heap "increment" %eax)
33766 $test-emit-subx-stmt-primitive-register:initialize-formal-var:
33767
33768 68/push 0/imm32/register
33769 68/push 0/imm32/register
33770 68/push 0/imm32/no-stack-offset
33771 68/push 1/imm32/block-depth
33772 ff 6/subop/push *(ecx+0x10)
33773 68/push 0x11/imm32/alloc-id:fake
33774 68/push 0/imm32/name
33775 68/push 0/imm32/name
33776 68/push 0x11/imm32/alloc-id:fake:payload
33777 89/<- %ebx 4/r32/esp
33778 $test-emit-subx-stmt-primitive-register:initialize-formal-var-name:
33779
33780 8d/copy-address *(ebx+4) 0/r32/eax
33781 (copy-array Heap "dummy" %eax)
33782 $test-emit-subx-stmt-primitive-register:initialize-formal-register:
33783
33784 8d/copy-address *(ebx+0x1c) 0/r32/eax
33785 (copy-array Heap "*" %eax)
33786 $test-emit-subx-stmt-primitive-register:initialize-var-list:
33787
33788 68/push 0/imm32/next
33789 68/push 0/imm32/next
33790 53/push-ebx/formal-var
33791 68/push 0x11/imm32/alloc-id:fake
33792 68/push 0x11/imm32/alloc-id:fake:payload
33793 89/<- %ebx 4/r32/esp
33794 $test-emit-subx-stmt-primitive-register:initialize-primitive:
33795
33796 68/push 0/imm32/next
33797 68/push 0/imm32/next
33798 68/push 0/imm32/no-x32
33799 68/push 0/imm32/no-xm32
33800 68/push 0/imm32/no-disp32
33801 68/push 0/imm32/no-imm8
33802 68/push 0/imm32/no-imm32
33803 68/push 0/imm32/no-r32
33804 68/push 3/imm32/rm32-is-first-output
33805 68/push 0/imm32/subx-name
33806 68/push 0/imm32/subx-name
33807 53/push-ebx/outputs
33808 68/push 0x11/imm32/alloc-id:fake
33809 68/push 0/imm32/no-inouts
33810 68/push 0/imm32/no-inouts
33811 68/push 0/imm32/name
33812 68/push 0/imm32/name
33813 89/<- %ebx 4/r32/esp
33814 $test-emit-subx-stmt-primitive-register:initialize-primitive-name:
33815
33816 (copy-array Heap "increment" %ebx)
33817 $test-emit-subx-stmt-primitive-register:initialize-primitive-subx-name:
33818
33819 8d/copy-address *(ebx+0x18) 0/r32/eax
33820 (copy-array Heap "ff 0/subop/increment" %eax)
33821
33822 c7 0/subop/copy *Curr-block-depth 0/imm32
33823 (emit-subx-stmt _test-output-buffered-file %esi %ebx 0 Stderr 0)
33824 (flush _test-output-buffered-file)
33825 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
33831
33832 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-primitive-register")
33833
33834 89/<- %esp 5/r32/ebp
33835 5d/pop-to-ebp
33836 c3/return
33837
33838 test-emit-subx-stmt-select-primitive:
33839
33840
33841
33842
33843
33844
33845
33846
33847
33848
33849
33850
33851
33852
33853
33854
33855
33856
33857
33858 55/push-ebp
33859 89/<- %ebp 4/r32/esp
33860
33861 (clear-stream _test-output-stream)
33862 (clear-stream $_test-output-buffered-file->buffer)
33863 $test-emit-subx-stmt-select-primitive:initialize-type:
33864
33865 68/push 0/imm32/right:null
33866 68/push 0/imm32/right:null
33867 68/push 0/imm32/left:unused
33868 68/push 1/imm32/value:int
33869 68/push 1/imm32/is-atom?:true
33870 68/push 0x11/imm32/alloc-id:fake:payload
33871 89/<- %ecx 4/r32/esp
33872 $test-emit-subx-stmt-select-primitive:initialize-var:
33873
33874 68/push 0/imm32/register
33875 68/push 0/imm32/register
33876 68/push 0/imm32/no-stack-offset
33877 68/push 1/imm32/block-depth
33878 51/push-ecx
33879 68/push 0x11/imm32/alloc-id:fake
33880 68/push 0/imm32/name
33881 68/push 0/imm32/name
33882 68/push 0x11/imm32/alloc-id:fake:payload
33883 89/<- %ecx 4/r32/esp
33884 $test-emit-subx-stmt-select-primitive:initialize-var-name:
33885
33886 8d/copy-address *(ecx+4) 0/r32/eax
33887 (copy-array Heap "foo" %eax)
33888 $test-emit-subx-stmt-select-primitive:initialize-var-register:
33889
33890 8d/copy-address *(ecx+0x1c) 0/r32/eax
33891 (copy-array Heap "eax" %eax)
33892 $test-emit-subx-stmt-select-primitive:initialize-stmt-var:
33893
33894 68/push 0/imm32/is-deref:false
33895 68/push 0/imm32/next
33896 68/push 0/imm32/next
33897 51/push-ecx/var-foo
33898 68/push 0x11/imm32/alloc-id:fake
33899 68/push 0x11/imm32/alloc-id:fake:payload
33900 89/<- %ebx 4/r32/esp
33901 $test-emit-subx-stmt-select-primitive:initialize-stmt:
33902
33903 53/push-ebx/outputs
33904 68/push 0x11/imm32/alloc-id:fake
33905 68/push 0/imm32/no-inouts
33906 68/push 0/imm32/no-inouts
33907 68/push 0/imm32/operation
33908 68/push 0/imm32/operation
33909 68/push 1/imm32
33910 89/<- %esi 4/r32/esp
33911 $test-emit-subx-stmt-select-primitive:initialize-stmt-operation:
33912
33913 8d/copy-address *(esi+4) 0/r32/eax
33914 (copy-array Heap "increment" %eax)
33915 $test-emit-subx-stmt-select-primitive:initialize-formal-var:
33916
33917 68/push 0/imm32/register
33918 68/push 0/imm32/register
33919 68/push 0/imm32/no-stack-offset
33920 68/push 1/imm32/block-depth
33921 ff 6/subop/push *(ecx+0x10)
33922 68/push 0x11/imm32/alloc-id:fake
33923 68/push 0/imm32/name
33924 68/push 0/imm32/name
33925 68/push 0x11/imm32/alloc-id:fake:payload
33926 89/<- %ebx 4/r32/esp
33927 $test-emit-subx-stmt-select-primitive:initialize-formal-var-name:
33928
33929 8d/copy-address *(ebx+4) 0/r32/eax
33930 (copy-array Heap "dummy" %eax)
33931 $test-emit-subx-stmt-select-primitive:initialize-formal-register:
33932
33933 8d/copy-address *(ebx+0x1c) 0/r32/eax
33934 (copy-array Heap "*" %eax)
33935 $test-emit-subx-stmt-select-primitive:initialize-var-list:
33936
33937 68/push 0/imm32/next
33938 68/push 0/imm32/next
33939 53/push-ebx/formal-var
33940 68/push 0x11/imm32/alloc-id:fake
33941 68/push 0x11/imm32/alloc-id:fake:payload
33942 89/<- %ebx 4/r32/esp
33943 $test-emit-subx-stmt-select-primitive:initialize-primitive2:
33944
33945 68/push 0/imm32/next
33946 68/push 0/imm32/next
33947 68/push 0/imm32/no-x32
33948 68/push 0/imm32/no-xm32
33949 68/push 0/imm32/no-disp32
33950 68/push 0/imm32/no-imm8
33951 68/push 0/imm32/no-imm32
33952 68/push 0/imm32/no-r32
33953 68/push 3/imm32/rm32-is-first-output
33954 68/push 0/imm32/subx-name
33955 68/push 0/imm32/subx-name
33956 53/push-ebx/outputs
33957 68/push 0x11/imm32/alloc-id:fake
33958 68/push 0/imm32/no-inouts
33959 68/push 0/imm32/no-inouts
33960 68/push 0/imm32/name
33961 68/push 0/imm32/name
33962 68/push 0x11/imm32/alloc-id:fake:payload
33963 89/<- %edi 4/r32/esp
33964 $test-emit-subx-stmt-select-primitive:initialize-primitive2-name:
33965
33966 8d/copy-address *(edi+4) 0/r32/eax
33967 (copy-array Heap "increment" %eax)
33968 $test-emit-subx-stmt-select-primitive:initialize-primitive2-subx-name:
33969
33970 8d/copy-address *(edi+0x1c) 0/r32/eax
33971 (copy-array Heap "ff 0/subop/increment" %eax)
33972 $test-emit-subx-stmt-select-primitive:initialize-primitive:
33973
33974 57/push-edi
33975 68/push 0x11/imm32/alloc-id:fake
33976 68/push 0/imm32/no-x32
33977 68/push 0/imm32/no-xm32
33978 68/push 0/imm32/no-disp32
33979 68/push 0/imm32/no-imm8
33980 68/push 0/imm32/no-imm32
33981 68/push 0/imm32/no-r32
33982 68/push 1/imm32/rm32-is-first-inout
33983 68/push 0/imm32/subx-name
33984 68/push 0/imm32/subx-name
33985 68/push 0/imm32/no-outputs
33986 68/push 0/imm32/no-outputs
33987 53/push-ebx/inouts
33988 68/push 0x11/imm32/alloc-id:fake
33989 68/push 0/imm32/name
33990 68/push 0/imm32/name
33991 89/<- %ebx 4/r32/esp
33992 $test-emit-subx-stmt-select-primitive:initialize-primitive-name:
33993
33994 (copy-array Heap "increment" %ebx)
33995 $test-emit-subx-stmt-select-primitive:initialize-primitive-subx-name:
33996
33997 8d/copy-address *(ebx+0x18) 0/r32/eax
33998 (copy-array Heap "ff 0/subop/increment" %eax)
33999
34000 c7 0/subop/copy *Curr-block-depth 0/imm32
34001 (emit-subx-stmt _test-output-buffered-file %esi %ebx 0 Stderr 0)
34002 (flush _test-output-buffered-file)
34003 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
34009
34010 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive")
34011
34012 89/<- %esp 5/r32/ebp
34013 5d/pop-to-ebp
34014 c3/return
34015
34016 test-emit-subx-stmt-select-primitive-2:
34017
34018
34019
34020
34021
34022
34023
34024
34025
34026
34027
34028
34029
34030
34031
34032
34033
34034
34035
34036 55/push-ebp
34037 89/<- %ebp 4/r32/esp
34038
34039 (clear-stream _test-output-stream)
34040 (clear-stream $_test-output-buffered-file->buffer)
34041 $test-emit-subx-stmt-select-primitive-2:initialize-type:
34042
34043 68/push 0/imm32/right:null
34044 68/push 0/imm32/right:null
34045 68/push 0/imm32/left:unused
34046 68/push 1/imm32/value:int
34047 68/push 1/imm32/is-atom?:true
34048 68/push 0x11/imm32/alloc-id:fake:payload
34049 89/<- %ecx 4/r32/esp
34050 $test-emit-subx-stmt-select-primitive-2:initialize-var:
34051
34052 68/push 0/imm32/register
34053 68/push 0/imm32/register
34054 68/push 0/imm32/no-stack-offset
34055 68/push 1/imm32/block-depth
34056 51/push-ecx
34057 68/push 0x11/imm32/alloc-id:fake
34058 68/push 0/imm32/name
34059 68/push 0/imm32/name
34060 68/push 0x11/imm32/alloc-id:fake:payload
34061 89/<- %ecx 4/r32/esp
34062 $test-emit-subx-stmt-select-primitive-2:initialize-var-name:
34063
34064 8d/copy-address *(ecx+4) 0/r32/eax
34065 (copy-array Heap "foo" %eax)
34066 $test-emit-subx-stmt-select-primitive-2:initialize-var-register:
34067
34068 8d/copy-address *(ecx+0x1c) 0/r32/eax
34069 (copy-array Heap "eax" %eax)
34070 $test-emit-subx-stmt-select-primitive-2:initialize-stmt-var:
34071
34072 68/push 0/imm32/is-deref:false
34073 68/push 0/imm32/next
34074 68/push 0/imm32/next
34075 51/push-ecx/var-foo
34076 68/push 0x11/imm32/alloc-id:fake
34077 68/push 0x11/imm32/alloc-id:fake:payload
34078 89/<- %ebx 4/r32/esp
34079 $test-emit-subx-stmt-select-primitive-2:initialize-stmt:
34080
34081 68/push 0/imm32/no-outputs
34082 68/push 0/imm32/no-outputs
34083 53/push-ebx/inouts
34084 68/push 0x11/imm32/alloc-id:fake
34085 68/push 0/imm32/operation
34086 68/push 0/imm32/operation
34087 68/push 1/imm32
34088 89/<- %esi 4/r32/esp
34089 $test-emit-subx-stmt-select-primitive-2:initialize-stmt-operation:
34090
34091 8d/copy-address *(esi+4) 0/r32/eax
34092 (copy-array Heap "increment" %eax)
34093 $test-emit-subx-stmt-select-primitive-2:initialize-formal-var:
34094
34095 68/push 0/imm32/register
34096 68/push 0/imm32/register
34097 68/push 0/imm32/no-stack-offset
34098 68/push 1/imm32/block-depth
34099 ff 6/subop/push *(ecx+0x10)
34100 68/push 0x11/imm32/alloc-id:fake
34101 68/push 0/imm32/name
34102 68/push 0/imm32/name
34103 68/push 0x11/imm32/alloc-id:fake:payload
34104 89/<- %ebx 4/r32/esp
34105 $test-emit-subx-stmt-select-primitive-2:initialize-formal-var-name:
34106
34107 8d/copy-address *(ebx+4) 0/r32/eax
34108 (copy-array Heap "dummy" %eax)
34109 $test-emit-subx-stmt-select-primitive-2:initialize-formal-register:
34110
34111 8d/copy-address *(ebx+0x1c) 0/r32/eax
34112 (copy-array Heap "*" %eax)
34113 $test-emit-subx-stmt-select-primitive-2:initialize-var-list:
34114
34115 68/push 0/imm32/next
34116 68/push 0/imm32/next
34117 53/push-ebx/formal-var
34118 68/push 0x11/imm32/alloc-id:fake
34119 68/push 0x11/imm32/alloc-id:fake:payload
34120 89/<- %ebx 4/r32/esp
34121 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2:
34122
34123 68/push 0/imm32/next
34124 68/push 0/imm32/next
34125 68/push 0/imm32/no-x32
34126 68/push 0/imm32/no-xm32
34127 68/push 0/imm32/no-disp32
34128 68/push 0/imm32/no-imm8
34129 68/push 0/imm32/no-imm32
34130 68/push 0/imm32/no-r32
34131 68/push 3/imm32/rm32-is-first-output
34132 68/push 0/imm32/subx-name
34133 68/push 0/imm32/subx-name
34134 53/push-ebx/outputs
34135 68/push 0x11/imm32/alloc-id:fake
34136 68/push 0/imm32/no-inouts
34137 68/push 0/imm32/no-inouts
34138 68/push 0/imm32/name
34139 68/push 0/imm32/name
34140 68/push 0x11/imm32/alloc-id:fake:payload
34141 89/<- %edi 4/r32/esp
34142 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2-name:
34143
34144 8d/copy-address *(edi+4) 0/r32/eax
34145 (copy-array Heap "increment" %eax)
34146 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2-subx-name:
34147
34148 8d/copy-address *(edi+0x1c) 0/r32/eax
34149 (copy-array Heap "ff 0/subop/increment" %eax)
34150 $test-emit-subx-stmt-select-primitive-2:initialize-primitive:
34151
34152 57/push-edi
34153 68/push 0x11/imm32/alloc-id:fake
34154 68/push 0/imm32/no-x32
34155 68/push 0/imm32/no-xm32
34156 68/push 0/imm32/no-disp32
34157 68/push 0/imm32/no-imm8
34158 68/push 0/imm32/no-imm32
34159 68/push 0/imm32/no-r32
34160 68/push 1/imm32/rm32-is-first-inout
34161 68/push 0/imm32/subx-name
34162 68/push 0/imm32/subx-name
34163 68/push 0/imm32/no-outputs
34164 68/push 0/imm32/no-outputs
34165 53/push-ebx/inouts
34166 68/push 0x11/imm32/alloc-id:fake
34167 68/push 0/imm32/name
34168 68/push 0/imm32/name
34169 89/<- %ebx 4/r32/esp
34170 $test-emit-subx-stmt-select-primitive-2:initialize-primitive-name:
34171
34172 (copy-array Heap "increment" %ebx)
34173 $test-emit-subx-stmt-select-primitive-2:initialize-primitive-subx-name:
34174
34175 8d/copy-address *(ebx+0x18) 0/r32/eax
34176 (copy-array Heap "ff 0/subop/increment" %eax)
34177
34178 c7 0/subop/copy *Curr-block-depth 0/imm32
34179 (emit-subx-stmt _test-output-buffered-file %esi %ebx 0 Stderr 0)
34180 (flush _test-output-buffered-file)
34181 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
34187
34188 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive-2")
34189
34190 89/<- %esp 5/r32/ebp
34191 5d/pop-to-ebp
34192 c3/return
34193
34194 test-increment-register:
34195
34196
34197
34198
34199
34200
34201
34202
34203
34204
34205
34206
34207
34208 55/push-ebp
34209 89/<- %ebp 4/r32/esp
34210
34211 (clear-stream _test-output-stream)
34212 (clear-stream $_test-output-buffered-file->buffer)
34213 $test-increment-register:initialize-type:
34214
34215 68/push 0/imm32/right:null
34216 68/push 0/imm32/right:null
34217 68/push 0/imm32/left:unused
34218 68/push 1/imm32/value:int
34219 68/push 1/imm32/is-atom?:true
34220 68/push 0x11/imm32/alloc-id:fake:payload
34221 89/<- %ecx 4/r32/esp
34222 $test-increment-register:initialize-var:
34223
34224 68/push 0/imm32/register
34225 68/push 0/imm32/register
34226 68/push 0/imm32/no-stack-offset
34227 68/push 1/imm32/block-depth
34228 51/push-ecx
34229 68/push 0x11/imm32/alloc-id:fake
34230 68/push 0/imm32/name
34231 68/push 0/imm32/name
34232 68/push 0x11/imm32/alloc-id:fake:payload
34233 89/<- %ecx 4/r32/esp
34234 $test-increment-register:initialize-var-name:
34235
34236 8d/copy-address *(ecx+4) 0/r32/eax
34237 (copy-array Heap "foo" %eax)
34238 $test-increment-register:initialize-var-register:
34239
34240 8d/copy-address *(ecx+0x1c) 0/r32/eax
34241 (copy-array Heap "eax" %eax)
34242 $test-increment-register:initialize-stmt-var:
34243
34244 68/push 0/imm32/is-deref:false
34245 68/push 0/imm32/next
34246 68/push 0/imm32/next
34247 51/push-ecx/var-foo
34248 68/push 0x11/imm32/alloc-id:fake
34249 68/push 0x11/imm32/alloc-id:fake:payload
34250 89/<- %ebx 4/r32/esp
34251 $test-increment-register:initialize-stmt:
34252
34253 53/push-ebx/outputs
34254 68/push 0x11/imm32/alloc-id:fake
34255 68/push 0/imm32/no-inouts
34256 68/push 0/imm32/no-inouts
34257 68/push 0/imm32/operation
34258 68/push 0/imm32/operation
34259 68/push 1/imm32
34260 89/<- %esi 4/r32/esp
34261 $test-increment-register:initialize-stmt-operation:
34262
34263 8d/copy-address *(esi+4) 0/r32/eax
34264 (copy-array Heap "increment" %eax)
34265
34266 c7 0/subop/copy *Curr-block-depth 0/imm32
34267 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
34268 (flush _test-output-buffered-file)
34269 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
34275
34276 (check-next-stream-line-equal _test-output-stream "40/increment-eax" "F - test-increment-register")
34277
34278 89/<- %esp 5/r32/ebp
34279 5d/pop-to-ebp
34280 c3/return
34281
34282 test-add-reg-to-reg:
34283
34284
34285
34286
34287
34288 55/push-ebp
34289 89/<- %ebp 4/r32/esp
34290
34291 (clear-stream _test-output-stream)
34292 (clear-stream $_test-output-buffered-file->buffer)
34293 $test-add-reg-to-reg:initialize-type:
34294
34295 68/push 0/imm32/right:null
34296 68/push 0/imm32/right:null
34297 68/push 0/imm32/left:unused
34298 68/push 1/imm32/value:int
34299 68/push 1/imm32/is-atom?:true
34300 68/push 0x11/imm32/alloc-id:fake:payload
34301 89/<- %ecx 4/r32/esp
34302 $test-add-reg-to-reg:initialize-var1:
34303
34304 68/push 0/imm32/register
34305 68/push 0/imm32/register
34306 68/push 0/imm32/no-stack-offset
34307 68/push 1/imm32/block-depth
34308 51/push-ecx
34309 68/push 0x11/imm32/alloc-id:fake
34310 68/push 0/imm32/name
34311 68/push 0/imm32/name
34312 68/push 0x11/imm32/alloc-id:fake:payload
34313 89/<- %ecx 4/r32/esp
34314 $test-add-reg-to-reg:initialize-var1-name:
34315
34316 8d/copy-address *(ecx+4) 0/r32/eax
34317 (copy-array Heap "var1" %eax)
34318 $test-add-reg-to-reg:initialize-var1-register:
34319
34320 8d/copy-address *(ecx+0x1c) 0/r32/eax
34321 (copy-array Heap "eax" %eax)
34322 $test-add-reg-to-reg:initialize-var2:
34323
34324 68/push 0/imm32/register
34325 68/push 0/imm32/register
34326 68/push 0/imm32/no-stack-offset
34327 68/push 1/imm32/block-depth
34328 ff 6/subop/push *(ecx+0x10)
34329 68/push 0x11/imm32/alloc-id:fake
34330 68/push 0/imm32/name
34331 68/push 0/imm32/name
34332 68/push 0x11/imm32/alloc-id:fake:payload
34333 89/<- %edx 4/r32/esp
34334 $test-add-reg-to-reg:initialize-var2-name:
34335
34336 8d/copy-address *(edx+4) 0/r32/eax
34337 (copy-array Heap "var2" %eax)
34338 $test-add-reg-to-reg:initialize-var2-register:
34339
34340 8d/copy-address *(edx+0x1c) 0/r32/eax
34341 (copy-array Heap "ecx" %eax)
34342 $test-add-reg-to-reg:initialize-inouts:
34343
34344 68/push 0/imm32/is-deref:false
34345 68/push 0/imm32/next
34346 68/push 0/imm32/next
34347 52/push-edx/var2
34348 68/push 0x11/imm32/alloc-id:fake
34349 68/push 0x11/imm32/alloc-id:fake:payload
34350 89/<- %esi 4/r32/esp
34351 $test-add-reg-to-reg:initialize-outputs:
34352
34353 68/push 0/imm32/is-deref:false
34354 68/push 0/imm32/next
34355 68/push 0/imm32/next
34356 51/push-ecx/var1
34357 68/push 0x11/imm32/alloc-id:fake
34358 68/push 0x11/imm32/alloc-id:fake:payload
34359 89/<- %edi 4/r32/esp
34360 $test-add-reg-to-reg:initialize-stmt:
34361
34362 68/push 0/imm32/next
34363 68/push 0/imm32/next
34364 57/push-edi/outputs
34365 68/push 0x11/imm32/alloc-id:fake
34366 56/push-esi/inouts
34367 68/push 0x11/imm32/alloc-id:fake
34368 68/push 0/imm32/operation
34369 68/push 0/imm32/operation
34370 68/push 1/imm32/tag:stmt1
34371 89/<- %esi 4/r32/esp
34372 $test-add-reg-to-reg:initialize-stmt-operation:
34373
34374 8d/copy-address *(esi+4) 0/r32/eax
34375 (copy-array Heap "add" %eax)
34376
34377 c7 0/subop/copy *Curr-block-depth 0/imm32
34378 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
34379 (flush _test-output-buffered-file)
34380 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
34386
34387 (check-next-stream-line-equal _test-output-stream "01/add-to %eax 0x00000001/r32" "F - test-add-reg-to-reg")
34388
34389 89/<- %esp 5/r32/ebp
34390 5d/pop-to-ebp
34391 c3/return
34392
34393 test-add-reg-to-mem:
34394
34395
34396
34397
34398
34399 55/push-ebp
34400 89/<- %ebp 4/r32/esp
34401
34402 (clear-stream _test-output-stream)
34403 (clear-stream $_test-output-buffered-file->buffer)
34404 $test-add-reg-to-mem:initialize-type:
34405
34406 68/push 0/imm32/right:null
34407 68/push 0/imm32/right:null
34408 68/push 0/imm32/left:unused
34409 68/push 1/imm32/value:int
34410 68/push 1/imm32/is-atom?:true
34411 68/push 0x11/imm32/alloc-id:fake:payload
34412 89/<- %ecx 4/r32/esp
34413 $test-add-reg-to-mem:initialize-var1:
34414
34415 68/push 0/imm32/register
34416 68/push 0/imm32/register
34417 68/push 8/imm32/stack-offset
34418 68/push 1/imm32/block-depth
34419 51/push-ecx
34420 68/push 0x11/imm32/alloc-id:fake
34421 68/push 0/imm32/name
34422 68/push 0/imm32/name
34423 68/push 0x11/imm32/alloc-id:fake:payload
34424 89/<- %ecx 4/r32/esp
34425 $test-add-reg-to-mem:initialize-var1-name:
34426
34427 8d/copy-address *(ecx+4) 0/r32/eax
34428 (copy-array Heap "var1" %eax)
34429 $test-add-reg-to-mem:initialize-var2:
34430
34431 68/push 0/imm32/register
34432 68/push 0/imm32/register
34433 68/push 0/imm32/no-stack-offset
34434 68/push 1/imm32/block-depth
34435 ff 6/subop/push *(ecx+0x10)
34436 68/push 0x11/imm32/alloc-id:fake
34437 68/push 0/imm32/name
34438 68/push 0/imm32/name
34439 68/push 0x11/imm32/alloc-id:fake:payload
34440 89/<- %edx 4/r32/esp
34441 $test-add-reg-to-mem:initialize-var2-name:
34442
34443 8d/copy-address *(edx+4) 0/r32/eax
34444 (copy-array Heap "var2" %eax)
34445 $test-add-reg-to-mem:initialize-var2-register:
34446
34447 8d/copy-address *(edx+0x1c) 0/r32/eax
34448 (copy-array Heap "ecx" %eax)
34449 $test-add-reg-to-mem:initialize-inouts:
34450
34451 68/push 0/imm32/is-deref:false
34452 68/push 0/imm32/next
34453 68/push 0/imm32/next
34454 52/push-edx/var2
34455 68/push 0x11/imm32/alloc-id:fake
34456 68/push 0x11/imm32/alloc-id:fake:payload
34457 89/<- %esi 4/r32/esp
34458
34459 68/push 0/imm32/is-deref:false
34460 56/push-esi/next
34461 68/push 0x11/imm32/alloc-id:fake
34462 51/push-ecx/var1
34463 68/push 0x11/imm32/alloc-id:fake
34464 68/push 0x11/imm32/alloc-id:fake:payload
34465 89/<- %esi 4/r32/esp
34466 $test-add-reg-to-mem:initialize-stmt:
34467
34468 68/push 0/imm32/next
34469 68/push 0/imm32/next
34470 68/push 0/imm32/outputs
34471 68/push 0/imm32/outputs
34472 56/push-esi/inouts
34473 68/push 0x11/imm32/alloc-id:fake
34474 68/push 0/imm32/operation
34475 68/push 0/imm32/operation
34476 68/push 1/imm32/tag:stmt1
34477 89/<- %esi 4/r32/esp
34478 $test-add-reg-to-mem:initialize-stmt-operation:
34479
34480 8d/copy-address *(esi+4) 0/r32/eax
34481 (copy-array Heap "add-to" %eax)
34482
34483 c7 0/subop/copy *Curr-block-depth 0/imm32
34484 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
34485 (flush _test-output-buffered-file)
34486 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
34492
34493 (check-next-stream-line-equal _test-output-stream "01/add-to *(ebp+0x00000008) 0x00000001/r32" "F - test-add-reg-to-mem")
34494
34495 89/<- %esp 5/r32/ebp
34496 5d/pop-to-ebp
34497 c3/return
34498
34499 test-add-mem-to-reg:
34500
34501
34502
34503
34504
34505 55/push-ebp
34506 89/<- %ebp 4/r32/esp
34507
34508 (clear-stream _test-output-stream)
34509 (clear-stream $_test-output-buffered-file->buffer)
34510 $test-add-mem-to-reg:initialize-type:
34511
34512 68/push 0/imm32/right:null
34513 68/push 0/imm32/right:null
34514 68/push 0/imm32/left:unused
34515 68/push 1/imm32/value:int
34516 68/push 1/imm32/is-atom?:true
34517 68/push 0x11/imm32/alloc-id:fake:payload
34518 89/<- %ecx 4/r32/esp
34519 $test-add-mem-to-reg:initialize-var:
34520
34521 68/push 0/imm32/register
34522 68/push 0/imm32/register
34523 68/push 0/imm32/no-stack-offset
34524 68/push 1/imm32/block-depth
34525 51/push-ecx
34526 68/push 0x11/imm32/alloc-id:fake
34527 68/push 0/imm32/name
34528 68/push 0/imm32/name
34529 68/push 0x11/imm32/alloc-id:fake:payload
34530 89/<- %ecx 4/r32/esp
34531 $test-add-mem-to-reg:initialize-var-name:
34532
34533 8d/copy-address *(ecx+4) 0/r32/eax
34534 (copy-array Heap "var1" %eax)
34535 $test-add-mem-to-reg:initialize-var-register:
34536
34537 8d/copy-address *(ecx+0x1c) 0/r32/eax
34538 (copy-array Heap "eax" %eax)
34539 $test-add-mem-to-reg:initialize-var2:
34540
34541 68/push 0/imm32/register
34542 68/push 0/imm32/register
34543 68/push 8/imm32/stack-offset
34544 68/push 1/imm32/block-depth
34545 ff 6/subop/push *(ecx+0x10)
34546 68/push 0x11/imm32/alloc-id:fake
34547 68/push 0/imm32/name
34548 68/push 0/imm32/name
34549 68/push 0x11/imm32/alloc-id:fake:payload
34550 89/<- %edx 4/r32/esp
34551 $test-add-mem-to-reg:initialize-var2-name:
34552
34553 8d/copy-address *(edx+4) 0/r32/eax
34554 (copy-array Heap "var2" %eax)
34555 $test-add-mem-to-reg:initialize-inouts:
34556
34557 68/push 0/imm32/is-deref:false
34558 68/push 0/imm32/next
34559 68/push 0/imm32/next
34560 52/push-edx/var2
34561 68/push 0x11/imm32/alloc-id:fake
34562 68/push 0x11/imm32/alloc-id:fake:payload
34563 89/<- %esi 4/r32/esp
34564 $test-add-mem-to-reg:initialize-outputs:
34565
34566 68/push 0/imm32/is-deref:false
34567 68/push 0/imm32/next
34568 68/push 0/imm32/next
34569 51/push-ecx/var1
34570 68/push 0x11/imm32/alloc-id:fake
34571 68/push 0x11/imm32/alloc-id:fake:payload
34572 89/<- %edi 4/r32/esp
34573 $test-add-mem-to-reg:initialize-stmt:
34574
34575 68/push 0/imm32/next
34576 68/push 0/imm32/next
34577 57/push-edi/outputs
34578 68/push 0x11/imm32/alloc-id:fake
34579 56/push-esi/inouts
34580 68/push 0x11/imm32/alloc-id:fake
34581 68/push 0/imm32/operation
34582 68/push 0/imm32/operation
34583 68/push 1/imm32/tag:stmt1
34584 89/<- %esi 4/r32/esp
34585 $test-add-mem-to-reg:initialize-stmt-operation:
34586
34587 8d/copy-address *(esi+4) 0/r32/eax
34588 (copy-array Heap "add" %eax)
34589
34590 c7 0/subop/copy *Curr-block-depth 0/imm32
34591 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
34592 (flush _test-output-buffered-file)
34593 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
34599
34600 (check-next-stream-line-equal _test-output-stream "03/add *(ebp+0x00000008) 0x00000000/r32" "F - test-add-mem-to-reg")
34601
34602 89/<- %esp 5/r32/ebp
34603 5d/pop-to-ebp
34604 c3/return
34605
34606 test-add-literal-to-eax:
34607
34608
34609
34610
34611
34612 55/push-ebp
34613 89/<- %ebp 4/r32/esp
34614
34615 (clear-stream _test-output-stream)
34616 (clear-stream $_test-output-buffered-file->buffer)
34617 $test-add-literal-to-eax:initialize-var-type:
34618
34619 68/push 0/imm32/right:null
34620 68/push 0/imm32/right:null
34621 68/push 0/imm32/left:unused
34622 68/push 1/imm32/value:int
34623 68/push 1/imm32/is-atom?:true
34624 68/push 0x11/imm32/alloc-id:fake:payload
34625 89/<- %ecx 4/r32/esp
34626 $test-add-literal-to-eax:initialize-var:
34627
34628 68/push 0/imm32/register
34629 68/push 0/imm32/register
34630 68/push 0/imm32/no-stack-offset
34631 68/push 1/imm32/block-depth
34632 51/push-ecx
34633 68/push 0x11/imm32/alloc-id:fake
34634 68/push 0/imm32/name
34635 68/push 0/imm32/name
34636 68/push 0x11/imm32/alloc-id:fake:payload
34637 89/<- %ecx 4/r32/esp
34638 $test-add-literal-to-eax:initialize-var-name:
34639
34640 8d/copy-address *(ecx+4) 0/r32/eax
34641 (copy-array Heap "v" %eax)
34642 $test-add-literal-to-eax:initialize-var-register:
34643
34644 8d/copy-address *(ecx+0x1c) 0/r32/eax
34645 (copy-array Heap "eax" %eax)
34646 $test-add-literal-to-eax:initialize-literal-type:
34647
34648 68/push 0/imm32/right:null
34649 68/push 0/imm32/right:null
34650 68/push 0/imm32/left:unused
34651 68/push 0/imm32/value:literal
34652 68/push 1/imm32/is-atom?:true
34653 68/push 0x11/imm32/alloc-id:fake:payload
34654 89/<- %edx 4/r32/esp
34655 $test-add-literal-to-eax:initialize-literal:
34656
34657 68/push 0/imm32/register
34658 68/push 0/imm32/register
34659 68/push 0/imm32/no-stack-offset
34660 68/push 1/imm32/block-depth
34661 52/push-edx
34662 68/push 0x11/imm32/alloc-id:fake
34663 68/push 0/imm32/name
34664 68/push 0/imm32/name
34665 68/push 0x11/imm32/alloc-id:fake:payload
34666 89/<- %edx 4/r32/esp
34667 $test-add-literal-to-eax:initialize-literal-value:
34668
34669 8d/copy-address *(edx+4) 0/r32/eax
34670 (copy-array Heap "0x34" %eax)
34671 $test-add-literal-to-eax:initialize-inouts:
34672
34673 68/push 0/imm32/is-deref:false
34674 68/push 0/imm32/next
34675 68/push 0/imm32/next
34676 52/push-edx/l
34677 68/push 0x11/imm32/alloc-id:fake
34678 68/push 0x11/imm32/alloc-id:fake:payload
34679 89/<- %esi 4/r32/esp
34680 $test-add-literal-to-eax:initialize-outputs:
34681
34682 68/push 0/imm32/is-deref:false
34683 68/push 0/imm32/next
34684 68/push 0/imm32/next
34685 51/push-ecx/v
34686 68/push 0x11/imm32/alloc-id:fake
34687 68/push 0x11/imm32/alloc-id:fake:payload
34688 89/<- %edi 4/r32/esp
34689 $test-add-literal-to-eax:initialize-stmt:
34690
34691 68/push 0/imm32/next
34692 68/push 0/imm32/next
34693 57/push-edi/outputs
34694 68/push 0x11/imm32/alloc-id:fake
34695 56/push-esi/inouts
34696 68/push 0x11/imm32/alloc-id:fake
34697 68/push 0/imm32/operation
34698 68/push 0/imm32/operation
34699 68/push 1/imm32/tag:stmt1
34700 89/<- %esi 4/r32/esp
34701 $test-add-literal-to-eax:initialize-stmt-operation:
34702
34703 8d/copy-address *(esi+4) 0/r32/eax
34704 (copy-array Heap "add" %eax)
34705
34706 c7 0/subop/copy *Curr-block-depth 0/imm32
34707 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
34708 (flush _test-output-buffered-file)
34709 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
34715
34716 (check-next-stream-line-equal _test-output-stream "05/add-to-eax 0x34/imm32" "F - test-add-literal-to-eax")
34717
34718 89/<- %esp 5/r32/ebp
34719 5d/pop-to-ebp
34720 c3/return
34721
34722 test-add-literal-to-reg:
34723
34724
34725
34726
34727
34728 55/push-ebp
34729 89/<- %ebp 4/r32/esp
34730
34731 (clear-stream _test-output-stream)
34732 (clear-stream $_test-output-buffered-file->buffer)
34733 $test-add-literal-to-reg:initialize-var-type:
34734
34735 68/push 0/imm32/right:null
34736 68/push 0/imm32/right:null
34737 68/push 0/imm32/left:unused
34738 68/push 1/imm32/value:int
34739 68/push 1/imm32/is-atom?:true
34740 68/push 0x11/imm32/alloc-id:fake:payload
34741 89/<- %ecx 4/r32/esp
34742 $test-add-literal-to-reg:initialize-var:
34743
34744 68/push 0/imm32/register
34745 68/push 0/imm32/register
34746 68/push 0/imm32/no-stack-offset
34747 68/push 1/imm32/block-depth
34748 51/push-ecx
34749 68/push 0x11/imm32/alloc-id:fake
34750 68/push 0/imm32/name
34751 68/push 0/imm32/name
34752 68/push 0x11/imm32/alloc-id:fake:payload
34753 89/<- %ecx 4/r32/esp
34754 $test-add-literal-to-reg:initialize-var-name:
34755
34756 8d/copy-address *(ecx+4) 0/r32/eax
34757 (copy-array Heap "v" %eax)
34758 $test-add-literal-to-reg:initialize-var-register:
34759
34760 8d/copy-address *(ecx+0x1c) 0/r32/eax
34761 (copy-array Heap "ecx" %eax)
34762 $test-add-literal-to-reg:initialize-literal-type:
34763
34764 68/push 0/imm32/right:null
34765 68/push 0/imm32/right:null
34766 68/push 0/imm32/left:unused
34767 68/push 0/imm32/value:literal
34768 68/push 1/imm32/is-atom?:true
34769 68/push 0x11/imm32/alloc-id:fake:payload
34770 89/<- %edx 4/r32/esp
34771 $test-add-literal-to-reg:initialize-literal:
34772
34773 68/push 0/imm32/register
34774 68/push 0/imm32/register
34775 68/push 0/imm32/no-stack-offset
34776 68/push 1/imm32/block-depth
34777 52/push-edx
34778 68/push 0x11/imm32/alloc-id:fake
34779 68/push 0/imm32/name
34780 68/push 0/imm32/name
34781 68/push 0x11/imm32/alloc-id:fake:payload
34782 89/<- %edx 4/r32/esp
34783 $test-add-literal-to-reg:initialize-literal-value:
34784
34785 8d/copy-address *(edx+4) 0/r32/eax
34786 (copy-array Heap "0x34" %eax)
34787 $test-add-literal-to-reg:initialize-inouts:
34788
34789 68/push 0/imm32/is-deref:false
34790 68/push 0/imm32/next
34791 68/push 0/imm32/next
34792 52/push-edx/l
34793 68/push 0x11/imm32/alloc-id:fake
34794 68/push 0x11/imm32/alloc-id:fake:payload
34795 89/<- %esi 4/r32/esp
34796 $test-add-literal-to-reg:initialize-outputs:
34797
34798 68/push 0/imm32/is-deref:false
34799 68/push 0/imm32/next
34800 68/push 0/imm32/next
34801 51/push-ecx/v
34802 68/push 0x11/imm32/alloc-id:fake
34803 68/push 0x11/imm32/alloc-id:fake:payload
34804 89/<- %edi 4/r32/esp
34805 $test-add-literal-to-reg:initialize-stmt:
34806
34807 68/push 0/imm32/next
34808 68/push 0/imm32/next
34809 57/push-edi/outputs
34810 68/push 0x11/imm32/alloc-id:fake
34811 56/push-esi/inouts
34812 68/push 0x11/imm32/alloc-id:fake
34813 68/push 0/imm32/operation
34814 68/push 0/imm32/operation
34815 68/push 1/imm32/tag:stmt1
34816 89/<- %esi 4/r32/esp
34817 $test-add-literal-to-reg:initialize-stmt-operation:
34818
34819 8d/copy-address *(esi+4) 0/r32/eax
34820 (copy-array Heap "add" %eax)
34821
34822 c7 0/subop/copy *Curr-block-depth 0/imm32
34823 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
34824 (flush _test-output-buffered-file)
34825 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
34831
34832 (check-next-stream-line-equal _test-output-stream "81 0/subop/add %ecx 0x34/imm32" "F - test-add-literal-to-reg")
34833
34834 89/<- %esp 5/r32/ebp
34835 5d/pop-to-ebp
34836 c3/return
34837
34838 test-add-literal-to-mem:
34839
34840
34841
34842
34843
34844 55/push-ebp
34845 89/<- %ebp 4/r32/esp
34846
34847 (clear-stream _test-output-stream)
34848 (clear-stream $_test-output-buffered-file->buffer)
34849 $test-add-literal-to-mem:initialize-type:
34850
34851 68/push 0/imm32/right:null
34852 68/push 0/imm32/right:null
34853 68/push 0/imm32/left:unused
34854 68/push 1/imm32/value:int
34855 68/push 1/imm32/is-atom?:true
34856 68/push 0x11/imm32/alloc-id:fake:payload
34857 89/<- %ecx 4/r32/esp
34858 $test-add-literal-to-mem:initialize-var1:
34859
34860 68/push 0/imm32/register
34861 68/push 0/imm32/register
34862 68/push 8/imm32/stack-offset
34863 68/push 1/imm32/block-depth
34864 51/push-ecx
34865 68/push 0x11/imm32/alloc-id:fake
34866 68/push 0/imm32/name
34867 68/push 0/imm32/name
34868 68/push 0x11/imm32/alloc-id:fake:payload
34869 89/<- %ecx 4/r32/esp
34870 $test-add-literal-to-mem:initialize-var1-name:
34871
34872 8d/copy-address *(ecx+4) 0/r32/eax
34873 (copy-array Heap "var1" %eax)
34874 $test-add-literal-to-mem:initialize-literal-type:
34875
34876 68/push 0/imm32/right:null
34877 68/push 0/imm32/right:null
34878 68/push 0/imm32/left:unused
34879 68/push 0/imm32/value:literal
34880 68/push 1/imm32/is-atom?:true
34881 68/push 0x11/imm32/alloc-id:fake:payload
34882 89/<- %edx 4/r32/esp
34883 $test-add-literal-to-mem:initialize-literal:
34884
34885 68/push 0/imm32/register
34886 68/push 0/imm32/register
34887 68/push 0/imm32/no-stack-offset
34888 68/push 1/imm32/block-depth
34889 52/push-edx
34890 68/push 0x11/imm32/alloc-id:fake
34891 68/push 0/imm32/name
34892 68/push 0/imm32/name
34893 68/push 0x11/imm32/alloc-id:fake:payload
34894 89/<- %edx 4/r32/esp
34895 $test-add-literal-to-mem:initialize-literal-value:
34896
34897 8d/copy-address *(edx+4) 0/r32/eax
34898 (copy-array Heap "0x34" %eax)
34899 $test-add-literal-to-mem:initialize-inouts:
34900
34901 68/push 0/imm32/is-deref:false
34902 68/push 0/imm32/next
34903 68/push 0/imm32/next
34904 52/push-edx/l
34905 68/push 0x11/imm32/alloc-id:fake
34906 68/push 0x11/imm32/alloc-id:fake:payload
34907 89/<- %esi 4/r32/esp
34908
34909 68/push 0/imm32/is-deref:false
34910 56/push-esi/next
34911 68/push 0x11/imm32/alloc-id:fake
34912 51/push-ecx/var1
34913 68/push 0x11/imm32/alloc-id:fake
34914 68/push 0x11/imm32/alloc-id:fake:payload
34915 89/<- %esi 4/r32/esp
34916 $test-add-literal-to-mem:initialize-stmt:
34917
34918 68/push 0/imm32/next
34919 68/push 0/imm32/next
34920 68/push 0/imm32/outputs
34921 68/push 0/imm32/outputs
34922 56/push-esi/inouts
34923 68/push 0x11/imm32/alloc-id:fake
34924 68/push 0/imm32/operation
34925 68/push 0/imm32/operation
34926 68/push 1/imm32/tag:stmt1
34927 89/<- %esi 4/r32/esp
34928 $test-add-literal-to-mem:initialize-stmt-operation:
34929
34930 8d/copy-address *(esi+4) 0/r32/eax
34931 (copy-array Heap "add-to" %eax)
34932
34933 c7 0/subop/copy *Curr-block-depth 0/imm32
34934 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
34935 (flush _test-output-buffered-file)
34936 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
34942
34943 (check-next-stream-line-equal _test-output-stream "81 0/subop/add *(ebp+0x00000008) 0x34/imm32" "F - test-add-literal-to-mem")
34944
34945 89/<- %esp 5/r32/ebp
34946 5d/pop-to-ebp
34947 c3/return
34948
34949 test-shift-reg-by-literal:
34950
34951
34952
34953
34954
34955 55/push-ebp
34956 89/<- %ebp 4/r32/esp
34957
34958 (clear-stream _test-output-stream)
34959 (clear-stream $_test-output-buffered-file->buffer)
34960 $test-shift-reg-by-literal:initialize-var-type:
34961
34962 68/push 0/imm32/right:null
34963 68/push 0/imm32/right:null
34964 68/push 0/imm32/left:unused
34965 68/push 1/imm32/value:int
34966 68/push 1/imm32/is-atom?:true
34967 68/push 0x11/imm32/alloc-id:fake:payload
34968 89/<- %ecx 4/r32/esp
34969 $test-shift-reg-by-literal:initialize-var:
34970
34971 68/push 0/imm32/register
34972 68/push 0/imm32/register
34973 68/push 0/imm32/no-stack-offset
34974 68/push 1/imm32/block-depth
34975 51/push-ecx
34976 68/push 0x11/imm32/alloc-id:fake
34977 68/push 0/imm32/name
34978 68/push 0/imm32/name
34979 68/push 0x11/imm32/alloc-id:fake:payload
34980 89/<- %ecx 4/r32/esp
34981 $test-shift-reg-by-literal:initialize-var-name:
34982
34983 8d/copy-address *(ecx+4) 0/r32/eax
34984 (copy-array Heap "v" %eax)
34985 $test-shift-reg-by-literal:initialize-var-register:
34986
34987 8d/copy-address *(ecx+0x1c) 0/r32/eax
34988 (copy-array Heap "ecx" %eax)
34989 $test-shift-reg-by-literal:initialize-literal-type:
34990
34991 68/push 0/imm32/right:null
34992 68/push 0/imm32/right:null
34993 68/push 0/imm32/left:unused
34994 68/push 0/imm32/value:literal
34995 68/push 1/imm32/is-atom?:true
34996 68/push 0x11/imm32/alloc-id:fake:payload
34997 89/<- %edx 4/r32/esp
34998 $test-shift-reg-by-literal:initialize-literal:
34999
35000 68/push 0/imm32/register
35001 68/push 0/imm32/register
35002 68/push 0/imm32/no-stack-offset
35003 68/push 1/imm32/block-depth
35004 52/push-edx
35005 68/push 0x11/imm32/alloc-id:fake
35006 68/push 0/imm32/name
35007 68/push 0/imm32/name
35008 68/push 0x11/imm32/alloc-id:fake:payload
35009 89/<- %edx 4/r32/esp
35010 $test-shift-reg-by-literal:initialize-literal-value:
35011
35012 8d/copy-address *(edx+4) 0/r32/eax
35013 (copy-array Heap "2" %eax)
35014 $test-shift-reg-by-literal:initialize-inouts:
35015
35016 68/push 0/imm32/is-deref:false
35017 68/push 0/imm32/next
35018 68/push 0/imm32/next
35019 52/push-edx/l
35020 68/push 0x11/imm32/alloc-id:fake
35021 68/push 0x11/imm32/alloc-id:fake:payload
35022 89/<- %esi 4/r32/esp
35023 $test-shift-reg-by-literal:initialize-outputs:
35024
35025 68/push 0/imm32/is-deref:false
35026 68/push 0/imm32/next
35027 68/push 0/imm32/next
35028 51/push-ecx/v
35029 68/push 0x11/imm32/alloc-id:fake
35030 68/push 0x11/imm32/alloc-id:fake:payload
35031 89/<- %edi 4/r32/esp
35032 $test-shift-reg-by-literal:initialize-stmt:
35033
35034 68/push 0/imm32/next
35035 68/push 0/imm32/next
35036 57/push-edi/outputs
35037 68/push 0x11/imm32/alloc-id:fake
35038 56/push-esi/inouts
35039 68/push 0x11/imm32/alloc-id:fake
35040 68/push 0/imm32/operation
35041 68/push 0/imm32/operation
35042 68/push 1/imm32/tag:stmt1
35043 89/<- %esi 4/r32/esp
35044 $test-shift-reg-by-literal:initialize-stmt-operation:
35045
35046 8d/copy-address *(esi+4) 0/r32/eax
35047 (copy-array Heap "shift-left" %eax)
35048
35049 c7 0/subop/copy *Curr-block-depth 0/imm32
35050 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
35051 (flush _test-output-buffered-file)
35052 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
35058
35059 (check-next-stream-line-equal _test-output-stream "c1/shift 4/subop/left %ecx 2/imm8" "F - test-shift-reg-by-literal")
35060
35061 89/<- %esp 5/r32/ebp
35062 5d/pop-to-ebp
35063 c3/return
35064
35065 test-shift-mem-by-literal:
35066
35067
35068
35069
35070
35071 55/push-ebp
35072 89/<- %ebp 4/r32/esp
35073
35074 (clear-stream _test-output-stream)
35075 (clear-stream $_test-output-buffered-file->buffer)
35076 $test-shift-mem-by-literal:initialize-type:
35077
35078 68/push 0/imm32/right:null
35079 68/push 0/imm32/right:null
35080 68/push 0/imm32/left:unused
35081 68/push 1/imm32/value:int
35082 68/push 1/imm32/is-atom?:true
35083 68/push 0x11/imm32/alloc-id:fake:payload
35084 89/<- %ecx 4/r32/esp
35085 $test-shift-mem-by-literal:initialize-var1:
35086
35087 68/push 0/imm32/register
35088 68/push 0/imm32/register
35089 68/push 8/imm32/stack-offset
35090 68/push 1/imm32/block-depth
35091 51/push-ecx
35092 68/push 0x11/imm32/alloc-id:fake
35093 68/push 0/imm32/name
35094 68/push 0/imm32/name
35095 68/push 0x11/imm32/alloc-id:fake:payload
35096 89/<- %ecx 4/r32/esp
35097 $test-shift-mem-by-literal:initialize-var1-name:
35098
35099 8d/copy-address *(ecx+4) 0/r32/eax
35100 (copy-array Heap "var1" %eax)
35101 $test-shift-mem-by-literal:initialize-literal-type:
35102
35103 68/push 0/imm32/right:null
35104 68/push 0/imm32/right:null
35105 68/push 0/imm32/left:unused
35106 68/push 0/imm32/value:literal
35107 68/push 1/imm32/is-atom?:true
35108 68/push 0x11/imm32/alloc-id:fake:payload
35109 89/<- %edx 4/r32/esp
35110 $test-shift-mem-by-literal:initialize-literal:
35111
35112 68/push 0/imm32/register
35113 68/push 0/imm32/register
35114 68/push 0/imm32/no-stack-offset
35115 68/push 1/imm32/block-depth
35116 52/push-edx
35117 68/push 0x11/imm32/alloc-id:fake
35118 68/push 0/imm32/name
35119 68/push 0/imm32/name
35120 68/push 0x11/imm32/alloc-id:fake:payload
35121 89/<- %edx 4/r32/esp
35122 $test-shift-mem-by-literal:initialize-literal-value:
35123
35124 8d/copy-address *(edx+4) 0/r32/eax
35125 (copy-array Heap "3" %eax)
35126 $test-shift-mem-by-literal:initialize-inouts:
35127
35128 68/push 0/imm32/is-deref:false
35129 68/push 0/imm32/next
35130 68/push 0/imm32/next
35131 52/push-edx/l
35132 68/push 0x11/imm32/alloc-id:fake
35133 68/push 0x11/imm32/alloc-id:fake:payload
35134 89/<- %esi 4/r32/esp
35135
35136 68/push 0/imm32/is-deref:false
35137 56/push-esi/next
35138 68/push 0x11/imm32/alloc-id:fake
35139 51/push-ecx/var1
35140 68/push 0x11/imm32/alloc-id:fake
35141 68/push 0x11/imm32/alloc-id:fake:payload
35142 89/<- %esi 4/r32/esp
35143 $test-shift-mem-by-literal:initialize-stmt:
35144
35145 68/push 0/imm32/next
35146 68/push 0/imm32/next
35147 68/push 0/imm32/outputs
35148 68/push 0/imm32/outputs
35149 56/push-esi/inouts
35150 68/push 0x11/imm32/alloc-id:fake
35151 68/push 0/imm32/operation
35152 68/push 0/imm32/operation
35153 68/push 1/imm32/tag:stmt1
35154 89/<- %esi 4/r32/esp
35155 $test-shift-mem-by-literal:initialize-stmt-operation:
35156
35157 8d/copy-address *(esi+4) 0/r32/eax
35158 (copy-array Heap "shift-left" %eax)
35159
35160 c7 0/subop/copy *Curr-block-depth 0/imm32
35161 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
35162 (flush _test-output-buffered-file)
35163 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
35169
35170 (check-next-stream-line-equal _test-output-stream "c1/shift 4/subop/left *(ebp+0x00000008) 3/imm8" "F - test-shift-mem-by-literal")
35171
35172 89/<- %esp 5/r32/ebp
35173 5d/pop-to-ebp
35174 c3/return
35175
35176 test-compare-reg-with-reg:
35177
35178
35179
35180
35181
35182 55/push-ebp
35183 89/<- %ebp 4/r32/esp
35184
35185 (clear-stream _test-output-stream)
35186 (clear-stream $_test-output-buffered-file->buffer)
35187 $test-compare-reg-with-reg:initialize-type:
35188
35189 68/push 0/imm32/right:null
35190 68/push 0/imm32/right:null
35191 68/push 0/imm32/left:unused
35192 68/push 1/imm32/value:int
35193 68/push 1/imm32/is-atom?:true
35194 68/push 0x11/imm32/alloc-id:fake:payload
35195 89/<- %ecx 4/r32/esp
35196 $test-compare-reg-with-reg:initialize-var1:
35197
35198 68/push 0/imm32/register
35199 68/push 0/imm32/register
35200 68/push 0/imm32/no-stack-offset
35201 68/push 1/imm32/block-depth
35202 51/push-ecx
35203 68/push 0x11/imm32/alloc-id:fake
35204 68/push 0/imm32/name
35205 68/push 0/imm32/name
35206 68/push 0x11/imm32/alloc-id:fake:payload
35207 89/<- %ecx 4/r32/esp
35208 $test-compare-reg-with-reg:initialize-var1-name:
35209
35210 8d/copy-address *(ecx+4) 0/r32/eax
35211 (copy-array Heap "var1" %eax)
35212 $test-compare-reg-with-reg:initialize-var1-register:
35213
35214 8d/copy-address *(ecx+0x1c) 0/r32/eax
35215 (copy-array Heap "ecx" %eax)
35216 $test-compare-reg-with-reg:initialize-var2:
35217
35218 68/push 0/imm32/register
35219 68/push 0/imm32/register
35220 68/push 0/imm32/no-stack-offset
35221 68/push 1/imm32/block-depth
35222 ff 6/subop/push *(ecx+0x10)
35223 68/push 0x11/imm32/alloc-id:fake
35224 68/push 0/imm32/name
35225 68/push 0/imm32/name
35226 68/push 0x11/imm32/alloc-id:fake:payload
35227 89/<- %edx 4/r32/esp
35228 $test-compare-reg-with-reg:initialize-var2-name:
35229
35230 8d/copy-address *(edx+4) 0/r32/eax
35231 (copy-array Heap "var2" %eax)
35232 $test-compare-reg-with-reg:initialize-var2-register:
35233
35234 8d/copy-address *(edx+0x1c) 0/r32/eax
35235 (copy-array Heap "eax" %eax)
35236 $test-compare-reg-with-reg:initialize-inouts:
35237
35238 68/push 0/imm32/is-deref:false
35239 68/push 0/imm32/next
35240 68/push 0/imm32/next
35241 52/push-edx/var2
35242 68/push 0x11/imm32/alloc-id:fake
35243 68/push 0x11/imm32/alloc-id:fake:payload
35244 89/<- %esi 4/r32/esp
35245
35246 68/push 0/imm32/is-deref:false
35247 56/push-esi/next
35248 68/push 0x11/imm32/alloc-id:fake
35249 51/push-ecx/var1
35250 68/push 0x11/imm32/alloc-id:fake
35251 68/push 0x11/imm32/alloc-id:fake:payload
35252 89/<- %esi 4/r32/esp
35253 $test-compare-reg-with-reg:initialize-stmt:
35254
35255 68/push 0/imm32/next
35256 68/push 0/imm32/next
35257 68/push 0/imm32/outputs
35258 68/push 0/imm32/outputs
35259 56/push-esi/inouts
35260 68/push 0x11/imm32/alloc-id:fake
35261 68/push 0/imm32/operation
35262 68/push 0/imm32/operation
35263 68/push 1/imm32/tag:stmt1
35264 89/<- %esi 4/r32/esp
35265 $test-compare-reg-with-reg:initialize-stmt-operation:
35266
35267 8d/copy-address *(esi+4) 0/r32/eax
35268 (copy-array Heap "compare" %eax)
35269
35270 c7 0/subop/copy *Curr-block-depth 0/imm32
35271 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
35272 (flush _test-output-buffered-file)
35273 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
35279
35280 (check-next-stream-line-equal _test-output-stream "39/compare-> %ecx 0x00000000/r32" "F - test-compare-reg-with-reg")
35281
35282 89/<- %esp 5/r32/ebp
35283 5d/pop-to-ebp
35284 c3/return
35285
35286 test-compare-mem-with-reg:
35287
35288
35289
35290
35291
35292 55/push-ebp
35293 89/<- %ebp 4/r32/esp
35294
35295 (clear-stream _test-output-stream)
35296 (clear-stream $_test-output-buffered-file->buffer)
35297 $test-compare-mem-with-reg:initialize-type:
35298
35299 68/push 0/imm32/right:null
35300 68/push 0/imm32/right:null
35301 68/push 0/imm32/left:unused
35302 68/push 1/imm32/value:int
35303 68/push 1/imm32/is-atom?:true
35304 68/push 0x11/imm32/alloc-id:fake:payload
35305 89/<- %ecx 4/r32/esp
35306 $test-compare-mem-with-reg:initialize-var1:
35307
35308 68/push 0/imm32/register
35309 68/push 0/imm32/register
35310 68/push 8/imm32/stack-offset
35311 68/push 1/imm32/block-depth
35312 51/push-ecx
35313 68/push 0x11/imm32/alloc-id:fake
35314 68/push 0/imm32/name
35315 68/push 0/imm32/name
35316 68/push 0x11/imm32/alloc-id:fake:payload
35317 89/<- %ecx 4/r32/esp
35318 $test-compare-mem-with-reg:initialize-var1-name:
35319
35320 8d/copy-address *(ecx+4) 0/r32/eax
35321 (copy-array Heap "var1" %eax)
35322 $test-compare-mem-with-reg:initialize-var2:
35323
35324 68/push 0/imm32/register
35325 68/push 0/imm32/register
35326 68/push 0/imm32/no-stack-offset
35327 68/push 1/imm32/block-depth
35328 ff 6/subop/push *(ecx+0x10)
35329 68/push 0x11/imm32/alloc-id:fake
35330 68/push 0/imm32/name
35331 68/push 0/imm32/name
35332 68/push 0x11/imm32/alloc-id:fake:payload
35333 89/<- %edx 4/r32/esp
35334 $test-compare-mem-with-reg:initialize-var2-name:
35335
35336 8d/copy-address *(edx+4) 0/r32/eax
35337 (copy-array Heap "var2" %eax)
35338 $test-compare-mem-with-reg:initialize-var2-register:
35339
35340 8d/copy-address *(edx+0x1c) 0/r32/eax
35341 (copy-array Heap "eax" %eax)
35342 $test-compare-mem-with-reg:initialize-inouts:
35343
35344 68/push 0/imm32/is-deref:false
35345 68/push 0/imm32/next
35346 68/push 0/imm32/next
35347 52/push-edx/var2
35348 68/push 0x11/imm32/alloc-id:fake
35349 68/push 0x11/imm32/alloc-id:fake:payload
35350 89/<- %esi 4/r32/esp
35351
35352 68/push 0/imm32/is-deref:false
35353 56/push-esi/next
35354 68/push 0x11/imm32/alloc-id:fake
35355 51/push-ecx/var1
35356 68/push 0x11/imm32/alloc-id:fake
35357 68/push 0x11/imm32/alloc-id:fake:payload
35358 89/<- %esi 4/r32/esp
35359 $test-compare-mem-with-reg:initialize-stmt:
35360
35361 68/push 0/imm32/next
35362 68/push 0/imm32/next
35363 68/push 0/imm32/outputs
35364 68/push 0/imm32/outputs
35365 56/push-esi/inouts
35366 68/push 0x11/imm32/alloc-id:fake
35367 68/push 0/imm32/operation
35368 68/push 0/imm32/operation
35369 68/push 1/imm32/tag:stmt1
35370 89/<- %esi 4/r32/esp
35371 $test-compare-mem-with-reg:initialize-stmt-operation:
35372
35373 8d/copy-address *(esi+4) 0/r32/eax
35374 (copy-array Heap "compare" %eax)
35375
35376 c7 0/subop/copy *Curr-block-depth 0/imm32
35377 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
35378 (flush _test-output-buffered-file)
35379 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
35385
35386 (check-next-stream-line-equal _test-output-stream "39/compare-> *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-mem-with-reg")
35387
35388 89/<- %esp 5/r32/ebp
35389 5d/pop-to-ebp
35390 c3/return
35391
35392 test-compare-reg-with-mem:
35393
35394
35395
35396
35397
35398 55/push-ebp
35399 89/<- %ebp 4/r32/esp
35400
35401 (clear-stream _test-output-stream)
35402 (clear-stream $_test-output-buffered-file->buffer)
35403 $test-compare-reg-with-mem:initialize-type:
35404
35405 68/push 0/imm32/right:null
35406 68/push 0/imm32/right:null
35407 68/push 0/imm32/left:unused
35408 68/push 1/imm32/value:int
35409 68/push 1/imm32/is-atom?:true
35410 68/push 0x11/imm32/alloc-id:fake:payload
35411 89/<- %ecx 4/r32/esp
35412 $test-compare-reg-with-mem:initialize-var1:
35413
35414 68/push 0/imm32/register
35415 68/push 0/imm32/register
35416 68/push 0/imm32/no-stack-offset
35417 68/push 1/imm32/block-depth
35418 51/push-ecx
35419 68/push 0x11/imm32/alloc-id:fake
35420 68/push 0/imm32/name
35421 68/push 0/imm32/name
35422 68/push 0x11/imm32/alloc-id:fake:payload
35423 89/<- %ecx 4/r32/esp
35424 $test-compare-reg-with-mem:initialize-var1-name:
35425
35426 8d/copy-address *(ecx+4) 0/r32/eax
35427 (copy-array Heap "var1" %eax)
35428 $test-compare-reg-with-mem:initialize-var1-register:
35429
35430 8d/copy-address *(ecx+0x1c) 0/r32/eax
35431 (copy-array Heap "eax" %eax)
35432 $test-compare-reg-with-mem:initialize-var2:
35433
35434 68/push 0/imm32/register
35435 68/push 0/imm32/register
35436 68/push 8/imm32/stack-offset
35437 68/push 1/imm32/block-depth
35438 ff 6/subop/push *(ecx+0x10)
35439 68/push 0x11/imm32/alloc-id:fake
35440 68/push 0/imm32/name
35441 68/push 0/imm32/name
35442 68/push 0x11/imm32/alloc-id:fake:payload
35443 89/<- %edx 4/r32/esp
35444 $test-compare-reg-with-mem:initialize-var2-name:
35445
35446 8d/copy-address *(edx+4) 0/r32/eax
35447 (copy-array Heap "var2" %eax)
35448 $test-compare-reg-with-mem:initialize-inouts:
35449
35450 68/push 0/imm32/is-deref:false
35451 68/push 0/imm32/next
35452 68/push 0/imm32/next
35453 52/push-edx/var2
35454 68/push 0x11/imm32/alloc-id:fake
35455 68/push 0x11/imm32/alloc-id:fake:payload
35456 89/<- %esi 4/r32/esp
35457
35458 68/push 0/imm32/is-deref:false
35459 56/push-esi/next
35460 68/push 0x11/imm32/alloc-id:fake
35461 51/push-ecx/var1
35462 68/push 0x11/imm32/alloc-id:fake
35463 68/push 0x11/imm32/alloc-id:fake:payload
35464 89/<- %esi 4/r32/esp
35465 $test-compare-reg-with-mem:initialize-stmt:
35466
35467 68/push 0/imm32/next
35468 68/push 0/imm32/next
35469 68/push 0/imm32/outputs
35470 68/push 0/imm32/outputs
35471 56/push-esi/inouts
35472 68/push 0x11/imm32/alloc-id:fake
35473 68/push 0/imm32/operation
35474 68/push 0/imm32/operation
35475 68/push 1/imm32/tag:stmt1
35476 89/<- %esi 4/r32/esp
35477 $test-compare-reg-with-mem:initialize-stmt-operation:
35478
35479 8d/copy-address *(esi+4) 0/r32/eax
35480 (copy-array Heap "compare" %eax)
35481
35482 c7 0/subop/copy *Curr-block-depth 0/imm32
35483 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
35484 (flush _test-output-buffered-file)
35485 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
35491
35492 (check-next-stream-line-equal _test-output-stream "3b/compare<- *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-reg-with-mem")
35493
35494 89/<- %esp 5/r32/ebp
35495 5d/pop-to-ebp
35496 c3/return
35497
35498 test-compare-mem-with-literal:
35499
35500
35501
35502
35503
35504 55/push-ebp
35505 89/<- %ebp 4/r32/esp
35506
35507 (clear-stream _test-output-stream)
35508 (clear-stream $_test-output-buffered-file->buffer)
35509 $test-compare-mem-with-literal:initialize-type:
35510
35511 68/push 0/imm32/right:null
35512 68/push 0/imm32/right:null
35513 68/push 0/imm32/left:unused
35514 68/push 1/imm32/value:int
35515 68/push 1/imm32/is-atom?:true
35516 68/push 0x11/imm32/alloc-id:fake:payload
35517 89/<- %ecx 4/r32/esp
35518 $test-compare-mem-with-literal:initialize-var1:
35519
35520 68/push 0/imm32/register
35521 68/push 0/imm32/register
35522 68/push 8/imm32/stack-offset
35523 68/push 1/imm32/block-depth
35524 51/push-ecx
35525 68/push 0x11/imm32/alloc-id:fake
35526 68/push 0/imm32/name
35527 68/push 0/imm32/name
35528 68/push 0x11/imm32/alloc-id:fake:payload
35529 89/<- %ecx 4/r32/esp
35530 $test-compare-mem-with-literal:initialize-var1-name:
35531
35532 8d/copy-address *(ecx+4) 0/r32/eax
35533 (copy-array Heap "var1" %eax)
35534 $test-compare-mem-with-literal:initialize-literal-type:
35535
35536 68/push 0/imm32/right:null
35537 68/push 0/imm32/right:null
35538 68/push 0/imm32/left:unused
35539 68/push 0/imm32/value:literal
35540 68/push 1/imm32/is-atom?:true
35541 68/push 0x11/imm32/alloc-id:fake:payload
35542 89/<- %edx 4/r32/esp
35543 $test-compare-mem-with-literal:initialize-literal:
35544
35545 68/push 0/imm32/register
35546 68/push 0/imm32/register
35547 68/push 0/imm32/no-stack-offset
35548 68/push 1/imm32/block-depth
35549 52/push-edx
35550 68/push 0x11/imm32/alloc-id:fake
35551 68/push 0/imm32/name
35552 68/push 0/imm32/name
35553 68/push 0x11/imm32/alloc-id:fake:payload
35554 89/<- %edx 4/r32/esp
35555 $test-compare-mem-with-literal:initialize-literal-value:
35556
35557 8d/copy-address *(edx+4) 0/r32/eax
35558 (copy-array Heap "0x34" %eax)
35559 $test-compare-mem-with-literal:initialize-inouts:
35560
35561 68/push 0/imm32/is-deref:false
35562 68/push 0/imm32/next
35563 68/push 0/imm32/next
35564 52/push-edx/l
35565 68/push 0x11/imm32/alloc-id:fake
35566 68/push 0x11/imm32/alloc-id:fake:payload
35567 89/<- %esi 4/r32/esp
35568
35569 68/push 0/imm32/is-deref:false
35570 56/push-esi/next
35571 68/push 0x11/imm32/alloc-id:fake
35572 51/push-ecx/var1
35573 68/push 0x11/imm32/alloc-id:fake
35574 68/push 0x11/imm32/alloc-id:fake:payload
35575 89/<- %esi 4/r32/esp
35576 $test-compare-mem-with-literal:initialize-stmt:
35577
35578 68/push 0/imm32/next
35579 68/push 0/imm32/next
35580 68/push 0/imm32/outputs
35581 68/push 0/imm32/outputs
35582 56/push-esi/inouts
35583 68/push 0x11/imm32/alloc-id:fake
35584 68/push 0/imm32/operation
35585 68/push 0/imm32/operation
35586 68/push 1/imm32/tag:stmt1
35587 89/<- %esi 4/r32/esp
35588 $test-compare-mem-with-literal:initialize-stmt-operation:
35589
35590 8d/copy-address *(esi+4) 0/r32/eax
35591 (copy-array Heap "compare" %eax)
35592
35593 c7 0/subop/copy *Curr-block-depth 0/imm32
35594 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
35595 (flush _test-output-buffered-file)
35596 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
35602
35603 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare *(ebp+0x00000008) 0x34/imm32" "F - test-compare-mem-with-literal")
35604
35605 89/<- %esp 5/r32/ebp
35606 5d/pop-to-ebp
35607 c3/return
35608
35609 test-compare-eax-with-literal:
35610
35611
35612
35613
35614
35615 55/push-ebp
35616 89/<- %ebp 4/r32/esp
35617
35618 (clear-stream _test-output-stream)
35619 (clear-stream $_test-output-buffered-file->buffer)
35620 $test-compare-eax-with-literal:initialize-type:
35621
35622 68/push 0/imm32/right:null
35623 68/push 0/imm32/right:null
35624 68/push 0/imm32/left:unused
35625 68/push 1/imm32/value:int
35626 68/push 1/imm32/is-atom?:true
35627 68/push 0x11/imm32/alloc-id:fake:payload
35628 89/<- %ecx 4/r32/esp
35629 $test-compare-eax-with-literal:initialize-var1:
35630
35631 68/push 0/imm32/register
35632 68/push 0/imm32/register
35633 68/push 0/imm32/no-stack-offset
35634 68/push 1/imm32/block-depth
35635 51/push-ecx
35636 68/push 0x11/imm32/alloc-id:fake
35637 68/push 0/imm32/name
35638 68/push 0/imm32/name
35639 68/push 0x11/imm32/alloc-id:fake:payload
35640 89/<- %ecx 4/r32/esp
35641 $test-compare-eax-with-literal:initialize-var1-name:
35642
35643 8d/copy-address *(ecx+4) 0/r32/eax
35644 (copy-array Heap "var1" %eax)
35645 $test-compare-eax-with-literal:initialize-var1-register:
35646
35647 8d/copy-address *(ecx+0x1c) 0/r32/eax
35648 (copy-array Heap "eax" %eax)
35649 $test-compare-eax-with-literal:initialize-literal-type:
35650
35651 68/push 0/imm32/right:null
35652 68/push 0/imm32/right:null
35653 68/push 0/imm32/left:unused
35654 68/push 0/imm32/value:literal
35655 68/push 1/imm32/is-atom?:true
35656 68/push 0x11/imm32/alloc-id:fake:payload
35657 89/<- %edx 4/r32/esp
35658 $test-compare-eax-with-literal:initialize-literal:
35659
35660 68/push 0/imm32/register
35661 68/push 0/imm32/register
35662 68/push 0/imm32/no-stack-offset
35663 68/push 1/imm32/block-depth
35664 52/push-edx
35665 68/push 0x11/imm32/alloc-id:fake
35666 68/push 0/imm32/name
35667 68/push 0/imm32/name
35668 68/push 0x11/imm32/alloc-id:fake:payload
35669 89/<- %edx 4/r32/esp
35670 $test-compare-eax-with-literal:initialize-literal-value:
35671
35672 8d/copy-address *(edx+4) 0/r32/eax
35673 (copy-array Heap "0x34" %eax)
35674 $test-compare-eax-with-literal:initialize-inouts:
35675
35676 68/push 0/imm32/is-deref:false
35677 68/push 0/imm32/next
35678 68/push 0/imm32/next
35679 52/push-edx/l
35680 68/push 0x11/imm32/alloc-id:fake
35681 68/push 0x11/imm32/alloc-id:fake:payload
35682 89/<- %esi 4/r32/esp
35683
35684 68/push 0/imm32/is-deref:false
35685 56/push-esi/next
35686 68/push 0x11/imm32/alloc-id:fake
35687 51/push-ecx/var1
35688 68/push 0x11/imm32/alloc-id:fake
35689 68/push 0x11/imm32/alloc-id:fake:payload
35690 89/<- %esi 4/r32/esp
35691 $test-compare-eax-with-literal:initialize-stmt:
35692
35693 68/push 0/imm32/next
35694 68/push 0/imm32/next
35695 68/push 0/imm32/outputs
35696 68/push 0/imm32/outputs
35697 56/push-esi/inouts
35698 68/push 0x11/imm32/alloc-id:fake
35699 68/push 0/imm32/operation
35700 68/push 0/imm32/operation
35701 68/push 1/imm32/tag:stmt1
35702 89/<- %esi 4/r32/esp
35703 $test-compare-eax-with-literal:initialize-stmt-operation:
35704
35705 8d/copy-address *(esi+4) 0/r32/eax
35706 (copy-array Heap "compare" %eax)
35707
35708 c7 0/subop/copy *Curr-block-depth 0/imm32
35709 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
35710 (flush _test-output-buffered-file)
35711 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
35717
35718 (check-next-stream-line-equal _test-output-stream "3d/compare-eax-with 0x34/imm32" "F - test-compare-eax-with-literal")
35719
35720 89/<- %esp 5/r32/ebp
35721 5d/pop-to-ebp
35722 c3/return
35723
35724 test-compare-reg-with-literal:
35725
35726
35727
35728
35729
35730 55/push-ebp
35731 89/<- %ebp 4/r32/esp
35732
35733 (clear-stream _test-output-stream)
35734 (clear-stream $_test-output-buffered-file->buffer)
35735 $test-compare-reg-with-literal:initialize-type:
35736
35737 68/push 0/imm32/right:null
35738 68/push 0/imm32/right:null
35739 68/push 0/imm32/left:unused
35740 68/push 1/imm32/value:int
35741 68/push 1/imm32/is-atom?:true
35742 68/push 0x11/imm32/alloc-id:fake:payload
35743 89/<- %ecx 4/r32/esp
35744 $test-compare-reg-with-literal:initialize-var1:
35745
35746 68/push 0/imm32/register
35747 68/push 0/imm32/register
35748 68/push 0/imm32/no-stack-offset
35749 68/push 1/imm32/block-depth
35750 51/push-ecx
35751 68/push 0x11/imm32/alloc-id:fake
35752 68/push 0/imm32/name
35753 68/push 0/imm32/name
35754 68/push 0x11/imm32/alloc-id:fake:payload
35755 89/<- %ecx 4/r32/esp
35756 $test-compare-reg-with-literal:initialize-var1-name:
35757
35758 8d/copy-address *(ecx+4) 0/r32/eax
35759 (copy-array Heap "var1" %eax)
35760 $test-compare-reg-with-literal:initialize-var1-register:
35761
35762 8d/copy-address *(ecx+0x1c) 0/r32/eax
35763 (copy-array Heap "ecx" %eax)
35764 $test-compare-reg-with-literal:initialize-literal-type:
35765
35766 68/push 0/imm32/right:null
35767 68/push 0/imm32/right:null
35768 68/push 0/imm32/left:unused
35769 68/push 0/imm32/value:literal
35770 68/push 1/imm32/is-atom?:true
35771 68/push 0x11/imm32/alloc-id:fake:payload
35772 89/<- %edx 4/r32/esp
35773 $test-compare-reg-with-literal:initialize-literal:
35774
35775 68/push 0/imm32/register
35776 68/push 0/imm32/register
35777 68/push 0/imm32/no-stack-offset
35778 68/push 1/imm32/block-depth
35779 52/push-edx
35780 68/push 0x11/imm32/alloc-id:fake
35781 68/push 0/imm32/name
35782 68/push 0/imm32/name
35783 68/push 0x11/imm32/alloc-id:fake:payload
35784 89/<- %edx 4/r32/esp
35785 $test-compare-reg-with-literal:initialize-literal-value:
35786
35787 8d/copy-address *(edx+4) 0/r32/eax
35788 (copy-array Heap "0x34" %eax)
35789 $test-compare-reg-with-literal:initialize-inouts:
35790
35791 68/push 0/imm32/is-deref:false
35792 68/push 0/imm32/next
35793 68/push 0/imm32/next
35794 52/push-edx/l
35795 68/push 0x11/imm32/alloc-id:fake
35796 68/push 0x11/imm32/alloc-id:fake:payload
35797 89/<- %esi 4/r32/esp
35798
35799 68/push 0/imm32/is-deref:false
35800 56/push-esi/next
35801 68/push 0x11/imm32/alloc-id:fake
35802 51/push-ecx/var1
35803 68/push 0x11/imm32/alloc-id:fake
35804 68/push 0x11/imm32/alloc-id:fake:payload
35805 89/<- %esi 4/r32/esp
35806 $test-compare-reg-with-literal:initialize-stmt:
35807
35808 68/push 0/imm32/next
35809 68/push 0/imm32/next
35810 68/push 0/imm32/outputs
35811 68/push 0/imm32/outputs
35812 56/push-esi/inouts
35813 68/push 0x11/imm32/alloc-id:fake
35814 68/push 0/imm32/operation
35815 68/push 0/imm32/operation
35816 68/push 1/imm32/tag:stmt1
35817 89/<- %esi 4/r32/esp
35818 $test-compare-reg-with-literal:initialize-stmt-operation:
35819
35820 8d/copy-address *(esi+4) 0/r32/eax
35821 (copy-array Heap "compare" %eax)
35822
35823 c7 0/subop/copy *Curr-block-depth 0/imm32
35824 (emit-subx-stmt _test-output-buffered-file %esi Primitives 0 Stderr 0)
35825 (flush _test-output-buffered-file)
35826 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
35832
35833 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare %ecx 0x34/imm32" "F - test-compare-reg-with-literal")
35834
35835 89/<- %esp 5/r32/ebp
35836 5d/pop-to-ebp
35837 c3/return
35838
35839 test-emit-subx-stmt-function-call:
35840
35841
35842
35843
35844
35845
35846
35847
35848
35849
35850
35851
35852
35853
35854
35855
35856
35857 55/push-ebp
35858 89/<- %ebp 4/r32/esp
35859
35860 (clear-stream _test-output-stream)
35861 (clear-stream $_test-output-buffered-file->buffer)
35862 $test-emit-subx-function-call:initialize-type:
35863
35864 68/push 0/imm32/right:null
35865 68/push 0/imm32/right:null
35866 68/push 0/imm32/left:unused
35867 68/push 1/imm32/value:int
35868 68/push 1/imm32/is-atom?:true
35869 68/push 0x11/imm32/alloc-id:fake:payload
35870 89/<- %ecx 4/r32/esp
35871 $test-emit-subx-function-call:initialize-var:
35872
35873 68/push 0/imm32/no-register
35874 68/push 0/imm32/no-register
35875 68/push -8/imm32/stack-offset
35876 68/push 1/imm32/block-depth
35877 51/push-ecx/type
35878 68/push 0x11/imm32/alloc-id:fake
35879 68/push 0/imm32/name
35880 68/push 0/imm32/name
35881 68/push 0x11/imm32/alloc-id:fake:payload
35882 89/<- %ecx 4/r32/esp
35883 $test-emit-subx-function-call:initialize-var-name:
35884
35885 8d/copy-address *(ecx+4) 0/r32/eax
35886 (copy-array Heap "foo" %eax)
35887 $test-emit-subx-function-call:initialize-stmt-var:
35888
35889 68/push 0/imm32/is-deref:false
35890 68/push 0/imm32/next
35891 68/push 0/imm32/next
35892 51/push-ecx/var-foo
35893 68/push 0x11/imm32/alloc-id:fake
35894 68/push 0x11/imm32/alloc-id:fake:payload
35895 89/<- %ebx 4/r32/esp
35896 $test-emit-subx-function-call:initialize-stmt:
35897
35898 68/push 0/imm32/no-outputs
35899 68/push 0/imm32/no-outputs
35900 53/push-ebx/inouts
35901 68/push 0x11/imm32/alloc-id:fake
35902 68/push 0/imm32/operation
35903 68/push 0/imm32/operation
35904 68/push 1/imm32/tag
35905 89/<- %esi 4/r32/esp
35906 $test-emit-subx-function-call:initialize-stmt-operation:
35907
35908 8d/copy-address *(esi+4) 0/r32/eax
35909 (copy-array Heap "f" %eax)
35910
35911 c7 0/subop/copy *Curr-block-depth 0/imm32
35912 (emit-subx-stmt _test-output-buffered-file %esi 0 0 Stderr 0)
35913 (flush _test-output-buffered-file)
35914 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
35920
35921 (check-next-stream-line-equal _test-output-stream "(f *(ebp+0xfffffff8))" "F - test-emit-subx-stmt-function-call")
35922
35923 89/<- %esp 5/r32/ebp
35924 5d/pop-to-ebp
35925 c3/return
35926
35927 test-emit-subx-stmt-function-call-with-literal-arg:
35928
35929
35930
35931
35932
35933
35934 55/push-ebp
35935 89/<- %ebp 4/r32/esp
35936
35937 (clear-stream _test-output-stream)
35938 (clear-stream $_test-output-buffered-file->buffer)
35939 $test-emit-subx-function-call-with-literal-arg:initialize-type:
35940
35941 68/push 0/imm32/right:null
35942 68/push 0/imm32/right:null
35943 68/push 0/imm32/left:unused
35944 68/push 0/imm32/value:literal
35945 68/push 1/imm32/is-atom?:true
35946 68/push 0x11/imm32/alloc-id:fake:payload
35947 89/<- %ecx 4/r32/esp
35948 $test-emit-subx-function-call-with-literal-arg:initialize-var:
35949
35950 68/push 0/imm32/no-register
35951 68/push 0/imm32/no-register
35952 68/push 0/imm32/no-stack-offset
35953 68/push 1/imm32/block-depth
35954 51/push-ecx/type
35955 68/push 0x11/imm32/alloc-id:fake
35956 68/push 0/imm32/name
35957 68/push 0/imm32/name
35958 68/push 0x11/imm32/alloc-id:fake:payload
35959 89/<- %ecx 4/r32/esp
35960 $test-emit-subx-function-call-with-literal-arg:initialize-var-name:
35961
35962 8d/copy-address *(ecx+4) 0/r32/eax
35963 (copy-array Heap "0x34" %eax)
35964 $test-emit-subx-function-call-with-literal-arg:initialize-stmt-var:
35965
35966 68/push 0/imm32/is-deref:false
35967 68/push 0/imm32/next
35968 68/push 0/imm32/next
35969 51/push-ecx/var-foo
35970 68/push 0x11/imm32/alloc-id:fake
35971 68/push 0x11/imm32/alloc-id:fake:payload
35972 89/<- %ebx 4/r32/esp
35973 $test-emit-subx-function-call-with-literal-arg:initialize-stmt:
35974
35975 68/push 0/imm32/no-outputs
35976 68/push 0/imm32/no-outputs
35977 53/push-ebx/inouts
35978 68/push 0x11/imm32/alloc-id:fake
35979 68/push 0/imm32/operation
35980 68/push 0/imm32/operation
35981 68/push 1/imm32/tag
35982 89/<- %esi 4/r32/esp
35983 $test-emit-subx-function-call-with-literal-arg:initialize-stmt-operation:
35984
35985 8d/copy-address *(esi+4) 0/r32/eax
35986 (copy-array Heap "f" %eax)
35987
35988 c7 0/subop/copy *Curr-block-depth 0/imm32
35989 (emit-subx-stmt _test-output-buffered-file %esi 0 %ebx 0 Stderr 0)
35990 (flush _test-output-buffered-file)
35991 +-- 6 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------
35997
35998 (check-next-stream-line-equal _test-output-stream "(f 0x34)" "F - test-emit-subx-stmt-function-call-with-literal-arg")
35999
36000 89/<- %esp 5/r32/ebp
36001 5d/pop-to-ebp
36002 c3/return
36003
36004 emit-indent:
36005
36006 55/push-ebp
36007 89/<- %ebp 4/r32/esp
36008
36009 50/push-eax
36010
36011 8b/-> *(ebp+0xc) 0/r32/eax
36012 {
36013
36014 3d/compare-eax-with 0/imm32
36015 7e/jump-if-<= break/disp8
36016 (write-buffered *(ebp+8) " ")
36017 48/decrement-eax
36018 eb/jump loop/disp8
36019 }
36020 $emit-indent:end:
36021
36022 58/pop-to-eax
36023
36024 89/<- %esp 5/r32/ebp
36025 5d/pop-to-ebp
36026 c3/return
36027
36028 emit-subx-prologue:
36029
36030 55/push-ebp
36031 89/<- %ebp 4/r32/esp
36032
36033 (write-buffered *(ebp+8) " # . prologue\n")
36034 (write-buffered *(ebp+8) " 55/push-ebp\n")
36035 (write-buffered *(ebp+8) " 89/<- %ebp 4/r32/esp\n")
36036 $emit-subx-prologue:end:
36037
36038 89/<- %esp 5/r32/ebp
36039 5d/pop-to-ebp
36040 c3/return
36041
36042 emit-subx-epilogue:
36043
36044 55/push-ebp
36045 89/<- %ebp 4/r32/esp
36046
36047 (write-buffered *(ebp+8) " # . epilogue\n")
36048 (write-buffered *(ebp+8) " 89/<- %esp 5/r32/ebp\n")
36049 (write-buffered *(ebp+8) " 5d/pop-to-ebp\n")
36050 (write-buffered *(ebp+8) " c3/return\n")
36051 $emit-subx-epilogue:end:
36052
36053 89/<- %esp 5/r32/ebp
36054 5d/pop-to-ebp
36055 c3/return